设计模式之：抽象工厂方法模式

业务场景：

（1）就是我们现在要生产的不是一个一个产品，而一个一个的产品组合
（2）比如说我们有产品ABC，现在第一种产品组合是A1+B3，第二种产品组合是A2+B2，第三种产品组合是A3+B3
（3）就是要对工厂模式进行进一步的增强

其核心思想是，如果需要一个工厂，这个工厂可以生产出相关联的一批产品，然后不同的工厂实现，会生产出一批不同的产品组合

/**
 * 抽象工厂方法模式
 */
public class AbstractFactoryPatternDemo {

    public static void main(String[] args) {
        // 产品A1+产品B3
        ProductA firstProductA = Factory1.get().createProductA();
        ProductB firstProductB = Factory1.get().createProductB();
        firstProductA.execute();
        firstProductB.execute();

        // 产品A2+产品B2
        ProductA secondProductA = Factory2.get().createProductA();
        ProductB secondProductB = Factory2.get().createProductB();
        secondProductA.execute();
        secondProductB.execute();

        // 产品A3+产品B3
        ProductA thirdProductA = Factory3.get().createProductA();
        ProductB thirdProductB = Factory3.get().createProductB();
        thirdProductA.execute();
        thirdProductB.execute();

        // 哪怕你有100个地方定义了产品组合，要调整组合的逻辑，只要修改一个工厂就可以了
    }

    public interface ProductA {

        void execute();

    }

    public static class ProductA1 implements ProductA {
        @Override
        public void execute() {
            System.out.println("产品A1的功能逻辑");
        }

    }

    public static class ProductA2 implements ProductA {
        @Override
        public void execute() {
            System.out.println("产品A2的功能逻辑");
        }

    }

    public static class ProductA3 implements ProductA {
        @Override
        public void execute() {
            System.out.println("产品A3的功能逻辑");
        }

    }

    public interface ProductB {

        void execute();

    }

    public static class ProductB1 implements ProductB {
        @Override
        public void execute() {
            System.out.println("产品B1的功能逻辑");
        }

    }

    public static class ProductB2 implements ProductB {
        @Override
        public void execute() {
            System.out.println("产品B2的功能逻辑");
        }

    }

    public static class ProductB3 implements ProductB {
        @Override
        public void execute() {
            System.out.println("产品B3的功能逻辑");
        }

    }

    public interface Factory {

        ProductA createProductA();

        ProductB createProductB();

    }

    public static class Factory1 implements Factory {

        private static final Factory1 instance = new Factory1();

        private Factory1() {

        }

        public static Factory get() {
            return instance;
        }

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

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

    }

    public static class Factory2 implements Factory {

        private static final Factory2 instance = new Factory2();

        private Factory2() {

        }

        public static Factory get() {
            return instance;
        }

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

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

    }

    public static class Factory3 implements Factory {

        private static final Factory3 instance = new Factory3();

        private Factory3() {

        }

        public static Factory get() {
            return instance;
        }

        @Override
        public ProductA createProductA() {
            return new ProductA3();
        }

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

    }

}