abstract factory 模式 -> 简单工厂模式的变种 -> 最复杂的一个变种

    场景：

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

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

    1. package com.example.designpattern.factory;
    3. public class AbstractFactoryPatternDemo {
    4.     public static void main(String[] args) {
    5.         // 产品A1+产品B1 => 产品A1+产品B3
    6.         ProductA firstProductA = Factory1.get().createProductA();
    7.         ProductB firstProductB = Factory1.get().createProductB();
    8.         firstProductA.execute();
    9.         firstProductB.execute();
    11.         //产品A2+产品B2
    12.         ProductA secondProductA = Factory2.get().createProductA();
    13.         ProductB secondProductB = Factory2.get().createProductB();
    14.         secondProductA.execute();
    15.         secondProductB.execute();
    17.         //产品A3+产品B3
    18.         ProductA thirdProductA = Factory3.get().createProductA();
    19.         ProductB thirdProductB = Factory3.get().createProductB();
    20.         thirdProductA.execute();
    21.         thirdProductB.execute();
    23.         // 哪怕你有100个地方定义了产品组合，要调整组合的逻辑，只要修改一个工厂就可以了
    24.     }
    26.     public interface ProductA {
    27.         void execute();
    28.     }
    29.     public static class ProductA1 implements ProductA {
    30.         public void execute() {
    31.             System.out.println("产品A1的功能逻辑");
    32.         }
    33.     }
    34.     public static class ProductA2 implements ProductA {
    35.         public void execute() {
    36.             System.out.println("产品A2的功能逻辑");
    37.         }
    38.     }
    39.     public static class ProductA3 implements ProductA {
    40.         public void execute() {
    41.             System.out.println("产品A3的功能逻辑");
    42.         }
    43.     }
    45.     public interface ProductB {
    46.         void execute();
    47.     }
    48.     public static class ProductB1 implements ProductB {
    49.         public void execute() {
    50.             System.out.println("产品B1的功能逻辑");
    51.         }
    52.     }
    53.     public static class ProductB2 implements ProductB {
    54.         public void execute() {
    55.             System.out.println("产品B2的功能逻辑");
    56.         }
    57.     }
    58.     public static class ProductB3 implements ProductB {
    59.         public void execute() {
    60.             System.out.println("产品B3的功能逻辑");
    61.         }
    62.     }
    64.     public interface Factory {
    65.         ProductA createProductA();
    66.         ProductB createProductB();
    67.     }
    69.     public static class Factory1 implements Factory{
    70.         public static final Factory1 instance = new Factory1();
    72.         public static Factory get(){
    73.             return instance;
    74.         }
    76.         public ProductA createProductA() {
    77.             return new ProductA1();
    78.         }
    80.         public ProductB createProductB() {
    81.             return new ProductB3();
    82.         }
    83.     }
    85.     public static class Factory2 implements Factory{
    86.         public static final Factory2 instance = new Factory2();
    88.         public static Factory get(){
    89.             return instance;
    90.         }
    92.         public ProductA createProductA() {
    93.             return new ProductA2();
    94.         }
    96.         public ProductB createProductB() {
    97.             return new ProductB2();
    98.         }
    99.     }
    100.     public static class Factory3 implements Factory{
    101.         public static final Factory3 instance = new Factory3();
    103.         public static Factory get(){
    104.             return instance;
    105.         }
    107.         public ProductA createProductA() {
    108.             return new ProductA3();
    109.         }
    111.         public ProductB createProductB() {
    112.             return new ProductB3();
    113.         }
    114.     }
    115. }