第3章 创建型模式-抽象工厂模式

创建型模式（Creational Pattern）是对类的实例化过程的抽象化，能够提供对象的创建和管理职责;

创建型模式共有5种：
■ 单例模式；
■ 工厂方法模式；
■ 抽象工厂模式；
■ 建造者模式；
■ 原型模式;

■ 为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类;
■ 抽象工厂模式是工厂方法模式的升级版本。在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式;

image.png

抽象工厂模式中的角色与工厂方法类似，也是有4个角色:
■ 抽象工厂（Abstract Factory）角色：
  该角色是抽象工厂模式的核心，与应用系统无关，任何创建对象的工厂类必须实现这个接口;
■ 具体工厂（Concrete Factory）角色：
  该角色实现了抽象工厂接口，含有选择合适的产品对象的逻辑，并且受到应用程序的调用以创建产品对象;
■ 抽象产品（Abstract Product）角色：
  该角色负责定义产品的共性，实现对产品最抽象的定义;
■ 具体产品（Concrete Product）角色：
  该角色实现抽象产品角色所声明的接口，抽象工厂模式所创建的任何产品对象都是某个具体产品角色的实例;

■ 抽象工厂模式的优点

抽象工厂模式是工厂方法模式的进一步抽象;
除了工厂方法模式的优点外，抽象工厂模式还具有下列优点:
■ 产品族内的约束为非公开状态，在不同的工厂中，各种产品可能具有不同的相互依赖关系，这些依赖关系由工厂封装在其内部，对于工厂的使用者是不可见的;
■ 生产线的扩展非常容易，如果要针对同一产品族建立新的生产线，只需要实现产品族中的所有产品接口并建立新的工厂类即可;

■ 抽象工厂模式的缺点

抽象工厂模式的最大缺点就是产品族本身的扩展非常困难，如果需要在产品族中增加一个新的产品类型，则需要修改多个接口，并且会影响已有的工厂类;

■ 抽象工厂模式的使用场景

■ 抽象工厂模式的使用场景是：
  当一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式;
■ 抽象工厂模式是一个简单的模式，使用的场景非常多;
  例如，应用需要涉及不同操作系统的时候，可以考虑使用抽象工厂模式;

■ 抽象工厂 AbstractFactory.java

public interface AbstractFactory {

    /**
     * 创建产品A
     */
    ProductA factoryA();

    ProductB factoryB();

}

■ 具体工厂 ConcreteFactory1.java

public class ConcreteFactory1 implements AbstractFactory{
    @Override
    public ProductA factoryA() {
        return new ProductA1();
    }

    @Override
    public ProductB factoryB() {
        return new ProductB1();
    }
}

■ 具体工厂 ConcreteFactory2.java

public class ConcreteFactory2 implements AbstractFactory{
    @Override
    public ProductA factoryA() {
        return new ProductA2();
    }

    @Override
    public ProductB factoryB() {
        return new ProductB2();
    }
}

■ 产品A的抽象接口 ProductA.java

public interface ProductA {

    /**
     * 产品A的公共方法
     */

    void method1();

    void method2();
}

■ 产品A的具体产品 ProductA1.java

public class ProductA1 implements ProductA{

    @Override
    public void method1() {
        System.out.println("等级为1的产品A的实现方法1");
    }

    @Override
    public void method2() {
        System.out.println("等级为1的产品A的实现方法2");
    }
}

■ 产品A的具体产品 ProductA2.java

public class ProductA2 implements ProductA{
    @Override
    public void method1() {
        System.out.println("等级为2的产品A的实现方法1");
    }

    @Override
    public void method2() {
        System.out.println("等级为2的产品A的实现方法2");
    }
}

■ 产品B的抽象接口 ProductB.java

public interface ProductB {

    /**
     * 产品B的公共方法
     */

    void method1();

    void method2();
}

■ 产品B的具体产品 ProductB1.java

public class ProductB1 implements ProductB{
    @Override
    public void method1() {
        System.out.println("等级为1的产品B的实现方法1");
    }

    @Override
    public void method2() {
        System.out.println("等级为1的产品B的实现方法2");
    }
}

■ 产品B的具体产品 ProductB2.java

public class ProductB2 implements ProductB{
    @Override
    public void method1() {
        System.out.println("等级为2的产品B的实现方法1");
    }

    @Override
    public void method2() {
        System.out.println("等级为2的产品B的实现方法2");

    }
}

■ 应用代码 ClientDemo.java

public class ClientDemo {

    public static void main(String[] args){
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();

        /**
         * 生产等级为1的产品A
         */
        ProductA a1 = new ProductA1();
        /**
         * 生产等级为2的产品A
         */
        ProductA a2 = new ProductA2();

        /**
         * 生产等级为1的产品B
         */
        ProductB b1 = new ProductB1();
        /**
         * 生产等级为2的产品B
         */
        ProductB b2 = new ProductB2();

        /**
         * 业务办理
         */
        a1.method1();
        a1.method2();

        a2.method1();
        a2.method2();

        b1.method1();
        b1.method2();

        b2.method1();
        b2.method2();

    }
}

# 控制台输出：
等级为1的产品A的实现方法1
等级为1的产品A的实现方法2
等级为2的产品A的实现方法1
等级为2的产品A的实现方法2
等级为1的产品B的实现方法1
等级为1的产品B的实现方法2
等级为2的产品B的实现方法1
等级为2的产品B的实现方法2

参考：
摘录 《设计模式（Java版）》韩敬海主编；（微信读书APP中有资源，可以直接阅读）