场景： （1）就是我们现在要生产的不是一个一个产品，而一个一个的产品组合 （2）比如说我们有产品ABC，现在第一种产品组合是A+B，第二种产品组合是B+C，第三种产品组合是A+C （3）就是要对工厂模式进行进一步的增强

1.常规

  1. package com.example.demo.pattern.factory;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class WithoutAbstractFactoryPatternDemo {
  8.     public static void main(String[] args) {
  9.         // 我们现在要创建产品A1+产品B1的组合
  10. //        ProductA productA1 = new ProductA1();
  11. //        ProductB productB1 = new ProductB1();
  12. //        
  13. //        productA1.execute();
  14. //        productB1.execute();
  16.         // 变成产品A1+产品B3的组合
  17.         ProductA productA1 = new ProductA1();
  18.         ProductB otherProductB3 = new ProductB3();
  20.         productA1.execute();
  21.         otherProductB3.execute();
  23.         // 问题来了，调整产品组合的这个行为，如果你手动创建产品组合的代码，有100个地方，A1+B1
  24.         // 一旦要调整，就是要对100个地方的代码，手动一点一点的去修改，组合的逻辑
  25.         // 不可维护，不可扩展
  27.         // 我们现在要创建产品A2+产品B2的组合
  28.         ProductA productA2 = new ProductA2();
  29.         ProductB productB2 = new ProductB2();
  31.         productA2.execute();
  32.         productB2.execute();
  34.         // 我们现在要创建产品A3+产品B3的组合
  35.         ProductA productA3 = new ProductA3();
  36.         ProductB productB3 = new ProductB3();
  38.         productA3.execute();
  39.         productB3.execute();
  40.     }
  42.     public interface ProductA {
  44.         void execute();
  46.     }
  48.     public static class ProductA1 implements ProductA {
  49.         @Override
  50.         public void execute() {
  51.             System.out.println("产品A1的功能逻辑");
  52.          }
  54.     }
  56.     public static class ProductA2 implements ProductA {
  57.         @Override
  58.         public void execute() {
  59.             System.out.println("产品A2的功能逻辑");
  60.          }
  62.     }
  64.     public static class ProductA3 implements ProductA {
  65.         @Override
  66.         public void execute() {
  67.             System.out.println("产品A3的功能逻辑");
  68.          }
  70.     }
  72.     public interface ProductB {
  74.         void execute();
  76.     }
  78.     public static class ProductB1 implements ProductB {
  79.         @Override
  80.         public void execute() {
  81.             System.out.println("产品B1的功能逻辑");
  82.          }
  84.     }
  86.     public static class ProductB2 implements ProductB {
  87.         @Override
  88.         public void execute() {
  89.             System.out.println("产品B2的功能逻辑");
  90.          }
  92.     }
  94.     public static class ProductB3 implements ProductB {
  95.         @Override
  96.         public void execute() {
  97.             System.out.println("产品B3的功能逻辑");
  98.          }
  100.     }
  102. }

2.抽象工程模式

  1. package com.example.demo.pattern.factory;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class AbstractFactoryPatternDemo {
  8.     public static void main(String[] args) {
  9.         // 产品A1+产品B1 -> 产品A1+产品B3
  10.         ProductA firstProductA = Factory1.get().createProductA();
  11.         ProductB firstProductB = Factory1.get().createProductB();
  12.         firstProductA.execute();
  13.         firstProductB.execute();
  15.         // 产品A2+产品B2
  16.         ProductA secondProductA = Factory2.get().createProductA();
  17.         ProductB secondProductB = Factory2.get().createProductB();
  18.         secondProductA.execute();
  19.         secondProductB.execute();
  21.         // 产品A3+产品B3
  22.         ProductA thirdProductA = Factory3.get().createProductA();
  23.         ProductB thirdProductB = Factory3.get().createProductB();
  24.         thirdProductA.execute();
  25.         thirdProductB.execute();
  27.         // 哪怕你有100个地方定义了产品组合，要调整组合的逻辑，只要修改一个工厂就可以了
  28.     }
  30.     public interface ProductA {
  32.         void execute();
  34.     }
  36.     public static class ProductA1 implements ProductA {
  37.         @Override
  38.         public void execute() {
  39.             System.out.println("产品A1的功能逻辑");
  40.          }
  42.     }
  44.     public static class ProductA2 implements ProductA {
  45.         @Override
  46.         public void execute() {
  47.             System.out.println("产品A2的功能逻辑");
  48.          }
  50.     }
  52.     public static class ProductA3 implements ProductA {
  53.         @Override
  54.         public void execute() {
  55.             System.out.println("产品A3的功能逻辑");
  56.          }
  58.     }
  60.     public interface ProductB {
  62.         void execute();
  64.     }
  66.     public static class ProductB1 implements ProductB {
  67.         @Override
  68.         public void execute() {
  69.             System.out.println("产品B1的功能逻辑");
  70.          }
  72.     }
  74.     public static class ProductB2 implements ProductB {
  75.         @Override
  76.         public void execute() {
  77.             System.out.println("产品B2的功能逻辑");
  78.          }
  80.     }
  82.     public static class ProductB3 implements ProductB {
  83.         @Override
  84.         public void execute() {
  85.             System.out.println("产品B3的功能逻辑");
  86.          }
  88.     }
  90.     public interface Factory {
  92.         ProductA createProductA();
  93.         ProductB createProductB();
  95.     }
  97.     public static class Factory1 implements Factory {
  99.         private static final Factory1 instance = new Factory1();
  101.         private Factory1() {
  103.         }
  105.         public static Factory get() {
  106.             return instance;
  107.         }
  108.         @Override
  109.         public ProductA createProductA() {
  110.             return new ProductA1();
  111.         }
  112.         @Override
  113.         public ProductB createProductB() {
  114.             return new ProductB3(); 
  115.         }
  117.     }
  119.     public static class Factory2 implements Factory {
  121.         private static final Factory2 instance = new Factory2();
  123.         private Factory2() {
  125.         }
  127.         public static Factory get() {
  128.             return instance;
  129.         }
  130.         @Override
  131.         public ProductA createProductA() {
  132.             return new ProductA2();
  133.         }
  134.         @Override
  135.         public ProductB createProductB() {
  136.             return new ProductB2(); 
  137.         }
  139.     }
  141.     public static class Factory3 implements Factory {
  143.         private static final Factory3 instance = new Factory3();
  145.         private Factory3() {
  147.         }
  149.         public static Factory get() {
  150.             return instance;
  151.         }
  152.         @Override
  153.         public ProductA createProductA() {
  154.             return new ProductA3();
  155.         }
  156.         @Override
  157.         public ProductB createProductB() {
  158.             return new ProductB3(); 
  159.         }
  161.     }
  163. }

3.说明

这种模式就更复杂了，在实际开发场景中，更加少见了。因为其核心思想是，如果需要一个工厂，这个工厂可以生产出相关联的一批产品，然后不同的工厂实现，会生产出一批不同的产品组合。