[23种设计模式][创建型]16.抽象工厂模式

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第16天，点击查看活动详情

1.意图：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

2.适用性：

• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

3.抽象工厂（Abstract Factory）模式的构成：

1. 抽象工厂角色（Abstract Factory）：声明生成抽象产品的方法
2. 具体工厂角色（Concrete Factory）：执行生成抽象产品的方法，生成一个具体的产品
3. 抽象产品（Abstract Product）：为一种产品声明接口
4. 具体产品（Concrete Product）：定义具体工厂生成的具体产品的对象，实现产品接口
5. 客户角色（Client）：我们的应用程序，使用抽象产品和抽象工厂生成对象

4.抽象工厂模式UML类图：

5.抽象工厂模式UML时序图：

6.总结：

• “抽象工厂模式”VS“工厂方法模式”： 工厂方法模式：

1. 一种产品对应一个工厂，一个工厂只能生产一种产品

• 抽象工厂模式：

1. 一个工厂可能生产多种（2+）产品
2. 同一个工厂生产的产品之间存在关联

7.代码示例：

抽象产品A：

public abstract class AbstractProductA {
}

具体产品A1：

public class ProductA1 extends AbstractProductA {

}

具体产品A2：

public class ProductA2 extends AbstractProductA {

}

抽象产品B：

public abstract class AbstractProductB {

    public abstract void interact(AbstractProductA a);
}

具体产品B1：

public class ProductB1 extends AbstractProductB {

    @Override
    public void interact(AbstractProductA a) {
        System.out.println(this.getClass().getName() + " interact with " + a.getClass().getName());
    }
}

具体产品B2：

public class ProductB2 extends AbstractProductB {

    @Override
    public void interact(AbstractProductA a) {
        System.out.println(this.getClass().getName() + " interact with " + a.getClass().getName());
    }
}

抽象工厂角色：

public abstract class AbstractFactory {

    public abstract AbstractProductA createProductA();

    public abstract AbstractProductB createProductB();
}

具体工厂角色1：

public class ConcreteFactory1 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

具体工厂角色2：

public class ConcreteFactory2 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

客户角色：

public class Client {

    private AbstractProductA a;
    private AbstractProductB b;

    public Client(AbstractFactory factory) {
        a = factory.createProductA();
        b = factory.createProductB();
    }

    public void run() {
        b.interact(a);
    }
}

测试类：

public class TestMain {

    public static void main(String[] args) {

        AbstractFactory factory1 = new ConcreteFactory1();

        Client client1 = new Client(factory1);

        client1.run();

        System.out.println("----------");

        AbstractFactory factory2 = new ConcreteFactory2();

        Client client2 = new Client(factory2);

        client2.run();
    }
}