设计模式之抽象工厂模式(6):最复杂的工厂模式变种

场景

场景:
(1)就是我们现在要生产的不是一个一个产品,而是一个一个的产品组合
(2)比如说我们有产品AB,现在第一种产品组合是A1+B1,第二种产品组合是A2+B2,第三种产品组合是A3+B3
(3)就是要对工厂模式进行进一步的增强

内容

1.不使用抽象工厂模式

1.1 类图

image.png

1.2 代码

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的功能逻辑");
        }
    }
}

2.使用抽象工厂模式

  1. 在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
  2. 抽象工厂模式就是在工厂模式下再抽象封装一层。

2.1 类图

image.png

2.2 代码

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的功能逻辑");
       }
   }
}

3.总结

3.1 不使用设计模式对比

  1. 调整产品组合的这个行为,如果你手动创建产品组合的代码,有1000个地方,A1+B1一旦要调整,可能产品组合1位:A1+A3 就是要对1000个地方的代码,手动一点一点的去修改,组合的逻辑不可维护,不可扩展

3.2 使用设计模式对比

  1. 哪怕你有1000个地方定义了产品组合,要调整组合的逻辑,只要修改一个工厂就可以了。
  2. 如果需要改动产品:A1+B1的组合 为:A1+B3 我们只需要找到:产品组1(Factory1) 把之前的B1改为B3即可。客户端调用不需要变动。
  3. 哪怕你有100个地方定义了产品组合,要调整组合的逻辑,只要修改一个工厂就可以了。

3.3 工厂模式自己的特点

优点:1、当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

缺点:1、产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的Factory里加代码,又要在具体的里面加代码。

评论

暂无评论