【05】【抽象工厂模式】

Abstract Factory（抽象工厂模式）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

类型：创建型模式

类图：

使用方法：

抽象产品类A

public abstract class AbstractProductA {
    /**
     * 每个产品的公有方法
     */
    public void shareMethod() {
        // 业务逻辑
    }

    /**
     * 每个产品相同的方法，不同的实现
     */
    public abstract void doSomething();
}

产品A1的实现类

public class ProductA1 extends AbstractProductA {
    @Override
    public void doSomething() {
        // 产品A1的实现方法
    }
}

产品A2的实现类

public class ProductA2 extends AbstractProductA {
    @Override
    public void doSomething() {
        // 产品A2的实现方法
    }
}

抽象产品类B

public abstract class AbstractProductB {
    /**
     * 每个产品的公有方法
     */
    public void shareMethod() {
        // 业务逻辑
    }

    /**
     * 每个产品相同的方法，不同的实现
     */
    public abstract void doSomething();
}

产品B1的实现类

public class ProductB1 extends AbstractProductB {
    @Override
    public void doSomething() {
        // 产品B1的实现方法
    }
}

产品B2的实现类

public class ProductB2 extends AbstractProductB {
    @Override
    public void doSomething() {
        // 产品B2的实现方法
    }
}

抽象工厂类

public abstract class AbstractCreator {
    /**
     * 创建A产品家族
     * @return A产品
     */
    public abstract AbstractProductA createProductA();
    /**
     * 创建B产品家族
     * @return B产品
     */
    public abstract AbstractProductB createProductB();
}

产品等级1的实现类

public class CreateA extends AbstractCreator {
    /**
     * 只生产产品等级为A1的产品
     *
     * @return 产品等级为A1的产品
     */
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    /**
     * 只生产产品等级为B1的产品
     *
     * @return 产品等级为B1的产品
     */
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

产品等级2的实现类

public class CreateB extends AbstractCreator {
    /**
     * 只生产产品等级为A2的产品
     *
     * @return 产品等级为A2的产品
     */
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    /**
     * 只生产产品等级为B2的产品
     *
     * @return 产品等级为B2的产品
     */
    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        // 定义两个工厂
        AbstractCreator creatorA = new CreateA();
        AbstractCreator creatorB = new CreateB();

        // 生产A1对象
        AbstractProductA a1 = creatorA.createProductA();
        // 生产A1对象
        AbstractProductA a2 = creatorB.createProductA();

        // 生产B1对象
        AbstractProductB b1 = creatorA.createProductB();
        //  生产B2对象
        AbstractProductB b2 = creatorB.createProductB();

        // ......
    }
}

优点：

1、封装性，每个产品的实现类不是高层模块要关心的。

2、产品族内的约束为非公开状态。

缺点：

1、产品族扩展非常困难。

使用场景：

一个对象族或是一组没有任何关系的对象都有相同的约束，则可以使用抽象工厂模式。

注意事项：

产品族扩展困难，产品等级非常容易扩展，也就是横向扩展容易，纵向扩展困难。