设计模式的抽象工厂模式（6）: 工厂模式最复杂的变体

场景:

（1）是我们不是一次生产一种产品，而是一种产品一个接一个地组合

（2）例如，我们有产品AB，现在第一个产品组合是A1 + B1，第二个产品组合是A2 + B2，第三个产品组合是A3 + B3

（3）是进一步增强工厂模型

public class NonPattern {
    public static void main(String[] args) {
        //第一种产品组合:A1+B1
        ProductA firstProductA1 = new ProductA1();
        ProductB firstProductB1 = new ProductB1();
        firstProductA1.excute();
        firstProductB1.excute();
        //第二种产品组合:A2+B2
        ProductA secondProductA2 = new ProductA2();
        ProductB secondProductB2 = new ProductB2();
        secondProductA2.excute();
        secondProductB2.excute();
        //第三种产品组合:A3+B3
        ProductA thirdProductA3 = new ProductA3();
        ProductB thirdProductB3 = new ProductB3();
        thirdProductA3.excute();
        thirdProductB3.excute();
    }
//======================产品抽象接口===================
    public interface ProductA{
         void excute();
    };
    public interface ProductB{
        void excute();
    };
//======================产品实体===================
    public static class ProductA1 implements ProductA{
        public void excute() {
            System.out.println("产品A1的功能逻辑");
        }
    }
    public static class ProductA2 implements ProductA{
        public void excute() {
            System.out.println("产品A2的功能逻辑");
        }
    }
    public static class ProductA3 implements ProductA{
        public void excute() {
            System.out.println("产品A3的功能逻辑");
        }
    }
    public static class ProductB1 implements ProductB{
        public void excute() {
            System.out.println("产品B1的功能逻辑");
        }
    }
    public static class ProductB2 implements ProductB{
        public void excute() {
            System.out.println("产品B2的功能逻辑");
        }
    }
    public static class ProductB3 implements ProductB{
        public void excute() {
            System.out.println("产品B3的功能逻辑");
        }
    }
}

在抽象工厂模式中，接口是负责创建相关对象的工厂，而无需显式指定其类. 每个生成的工厂都可以根据工厂模式提供对象. 抽象工厂模式是对工厂模式下的另一层进行抽象和封装.

public class AbstractFactoryPattern2 {
       public static void main(String[] args) {
           // 产品组1:产品A1+产品B1
           ProductA firstProductA = Product1Factory.getInstance().createProductA();
           ProductB firstProductB = Product1Factory.getInstance().createProductB();
           firstProductA.excute();
           firstProductB.excute();
           // 产品A2+产品B2
           ProductA secondProductA = Product2Factory.getInstance().createProductA();
           ProductB secondProductB = Product2Factory.getInstance().createProductB();
           secondProductA.excute();
           secondProductB.excute();
           // 产品A3+产品B3
           ProductA thirdProductA = Product3Factory.getInstance().createProductA();
           ProductB thirdProductB = Product3Factory.getInstance().createProductB();
           thirdProductA.excute();
           thirdProductB.excute();
   }
//======================工厂模式======================
//我们需要创建3个组合,那么我们创建3个不同工厂,如果组合需要改变,我们叫工厂里面改变对应的 商品即可
    public interface Factory{
       ProductA createProductA();
       ProductB createProductB();
   }
   public static class Product1Factory implements Factory{
       private static final Product1Factory instance = new Product1Factory();
       public static Factory getInstance(){
           return instance;
       }
       public ProductA createProductA() {
           return new ProductA1();
       }
       public ProductB createProductB() {
           return new ProductB1();
       }
   }
   public static class Product2Factory implements Factory{
       private static final Product2Factory instance = new Product2Factory();
       public static Factory getInstance() {
           return instance;
       }
       public ProductA createProductA() {
           return new ProductA2();
       }
       public ProductB createProductB() {
           return new ProductB2();
       }
   }
   public static class Product3Factory implements Factory{
       private static final Product3Factory instance = new Product3Factory();
       public static Factory getInstance() {
           return instance;
       }
       public ProductA createProductA() {
           return new ProductA3();
       }
       public ProductB createProductB() {
           return new ProductB3();
       }
   }
//=====================产品实体==================
   public interface ProductA{
       void excute();
   };
   public interface ProductB{
       void excute();
   };
   public interface ProductC{
       void excute();
   };
   public static class ProductA1 implements ProductA {
       public void excute() {
           System.out.println("产品A1的功能逻辑");
       }
   }
   public static class ProductA2 implements ProductA {
       public void excute() {
           System.out.println("产品A2的功能逻辑");
       }
   }
   public static class ProductA3 implements ProductA {
       public void excute() {
           System.out.println("产品A3的功能逻辑");
       }
   }
   public static class ProductB1 implements ProductB {
       public void excute() {
           System.out.println("产品B1的功能逻辑");
       }
   }
   public static class ProductB2 implements ProductB {
       public void excute() {
           System.out.println("产品B2的功能逻辑");
       }
   }
   public static class ProductB3 implements ProductB {
       public void excute() {
           System.out.println("产品B3的功能逻辑");
       }
   }
}

要调整产品组合的这种行为工厂模式类图，如果您手动创建产品组合的代码，则有1000个位置. 一旦需要调整A1 + B1，产品组合可能为1位: A1 + A3是手动编码1000个位置，一点一点地修改它，组合的逻辑不可维护工厂模式类图，并且不可扩展. 即使您在定义产品组合的位置有1000个，要调整组合的逻辑，只需修改工厂即可. 如果需要更改产品: A1 + B1的组合为: A1 + B3我们仅需查找: 产品组1（Factory1）将先前的B1更改为B3. 客户电话不需要更改. 即使您已在100个地方定义了产品组合，要调整组合的逻辑，只需修改工厂即可.

优点: 1.当一个产品系列中的多个对象设计为可一起使用时，可以确保客户始终只使用同一产品系列中的对象.

缺点: 1.扩展产品系列非常困难. 要添加系列的某个产品，必须在抽象的Factory中添加代码，并在具体的目录中添加代码.

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-186156-1.html