您现在的位置是：首页 >学无止境 >【地铁上的设计模式】--创建型模式：抽象工厂模式网站首页学无止境

这篇文章，我们来学习一下创建型模式中的另一个模式：抽象工厂模式

什么是抽象工厂模式

抽象工厂模式是一种创建型设计模式，它提供了一种方式来封装一组相关或相互依赖的对象的创建过程。抽象工厂模式将具体产品的创建与客户端代码分离开来，通过引入抽象工厂和抽象产品来实现对象的解耦和隐藏。抽象工厂负责定义一组用于创建一系列产品对象的方法，每个方法对应一个具体产品族的创建过程。具体工厂类实现抽象工厂接口，负责创建具体产品对象，并且每个具体工厂类只能创建一种具体产品族的对象。
抽象工厂模式涉及到四个角色：抽象产品、具体产品、抽象工厂和具体工厂。其中，抽象产品定义产品的接口规范，具体产品实现抽象产品的接口规范，抽象工厂定义工厂的接口规范，具体工厂实现抽象工厂的接口规范并负责具体产品的创建。
与工厂方法模式相比，抽象工厂模式的抽象程度更高，因为它不仅能够封装具体产品的创建过程，还能够封装具体产品族的创建过程。在使用抽象工厂模式时，客户端只需要关注抽象工厂和抽象产品，而不需要关注具体的实现细节。
抽象工厂模式适用于需要创建一组相关或相互依赖的对象的场景，例如需要创建一个由多个组成部分的复杂对象或者需要创建一组具有相同风格或主题的界面控件。抽象工厂模式可以保证产品的一致性和相互依赖性，同时还可以提供高度的灵活性和可扩展性，因为只需要增加新的具体产品类和对应的具体工厂类即可实现系统的扩展。

如何实现抽象工厂模式

实现抽象工厂模式需要遵循以下步骤：

1. 定义抽象产品类：抽象产品类定义产品的接口规范，包括产品的属性和方法等，所有具体产品类都必须实现这些接口规范。
2. 定义具体产品类：具体产品类实现抽象产品类的接口规范，是抽象产品的实际实现。
3. 定义抽象工厂类：抽象工厂类定义一组用于创建一系列产品对象的方法，每个方法对应一个具体产品族的创建过程。抽象工厂类是抽象工厂模式的核心，它负责定义产品的创建过程。
4. 定义具体工厂类：具体工厂类实现抽象工厂类的接口规范，并负责具体产品对象的创建。每个具体工厂类只能创建一种具体产品族的对象。

客户端代码调用：客户端代码只需要与抽象工厂和抽象产品进行交互，不需要关心具体产品的实现细节。
Java实现

// 抽象产品接口
interface ProductA {
    void use();
}

// 具体产品类A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("使用具体产品A1");
    }
}

// 具体产品类A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("使用具体产品A2");
    }
}

// 抽象产品接口
interface ProductB {
    void consume();
}

// 具体产品类B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void consume() {
        System.out.println("消费具体产品B1");
    }
}

// 具体产品类B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void consume() {
        System.out.println("消费具体产品B2");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建具体工厂对象
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();

        // 使用具体工厂对象创建具体产品对象
        ProductA productA1 = factory1.createProductA();
        ProductA productA2 = factory2.createProductA();
        ProductB productB1 = factory1.createProductB();
        ProductB productB2 = factory2.createProductB();

        // 使用产品
        productA1.use();
        productA2.use();
        productB1.consume();
        productB2.consume();
    }
}

C#实现

// 抽象产品接口
interface ProductA {
    void Use();
}

// 具体产品类A1
class ConcreteProductA1 : ProductA {
    public void Use() {
        Console.WriteLine("使用具体产品A1");
    }
}

// 具体产品类A2
class ConcreteProductA2 : ProductA {
    public void Use() {
        Console.WriteLine("使用具体产品A2");
    }
}

// 抽象产品接口
interface ProductB {
    void Consume();
}

// 具体产品类B1
class ConcreteProductB1 : ProductB {
    public void Consume() {
        Console.WriteLine("消费具体产品B1");
    }
}

// 具体产品类B2
class ConcreteProductB2 : ProductB {
    public void Consume() {
        Console.WriteLine("消费具体产品B2");
    }
}
interface AbstractFactory {
    ProductA CreateProductA();
    ProductB CreateProductB();
}

// 具体工厂类1
class ConcreteFactory1 : AbstractFactory {
    public ProductA CreateProductA() {
        return new ConcreteProductA1();
    }

    public ProductB CreateProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂类2
class ConcreteFactory2 : AbstractFactory {
    public ProductA CreateProductA() {
        return new ConcreteProductA2();
    }

    public ProductB CreateProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
class Client {
    static void Main(string[] args) {
        // 创建具体工厂对象
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();

        // 使用具体工厂对象创建具体产品对象
        ProductA productA1 = factory1.CreateProductA();
        ProductA productA2 = factory2.CreateProductA();
        ProductB productB1 = factory1.CreateProductB();
        ProductB productB2 = factory2.CreateProductB();

        // 使用产品
        productA1.Use();
        productA2.Use();
        productB1.Consume();
        productB2.Consume();
    }
}

上述代码中，我们定义了 ProductA、ProductB 两个抽象产品接口，以及具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1、ConcreteProductB2，这些类对应抽象工厂中定义的两个产品族。在抽象工厂接口 AbstractFactory 中，我们定义了 CreateProductA() 和 CreateProductB() 两个工厂方法，分别用于创建抽象产品 ProductA 和 ProductB 的具体产品对象。具体工厂类 ConcreteFactory1 和 ConcreteFactory2 实现了 AbstractFactory 接口，分别用于创建产品族1和产品族2的产品对象。在客户端代码中，我们先创建具体工厂对象，然后使用工厂方法分别创建具体产品对象，并使用这些产品对象进行一些操作。

总结

抽象工厂模式是一种创建型模式，它提供了一种封装一组相关或相互依赖对象的接口，而不需要指定它们的具体类。通过使用抽象工厂模式，客户端可以创建一组相关的产品对象，而无需知道它们的具体实现，优点在于方便地增加一组相关产品，同时保证它们之间的一致性。需要注意抽象工厂接口和抽象产品接口的设计，以及具体工厂类和具体产品类的实现。