設計模式之抽象工廠模式(6):最複雜的工廠模式變種

時間 2020-04-05

標籤設計模式抽象工廠複雜變種简体版

原文原文鏈接

場景

場景：
（1）就是咱們如今要生產的不是一個一個產品，而是一個一個的產品組合
（2）好比說咱們有產品AB，如今第一種產品組合是A1+B1，第二種產品組合是A2+B2，第三種產品組合是A3+B3
（3）就是要對工廠模式進行進一步的加強設計模式

內容

1.不使用抽象工廠模式

1.1 類圖

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.使用抽象工廠模式

在抽象工廠模式中，接口是負責建立一個相關對象的工廠，不須要顯式指定它們的類。每一個生成的工廠都能按照工廠模式提供對象。
抽象工廠模式就是在工廠模式下再抽象封裝一層。

2.1 類圖

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的功能邏輯");
       }
   }
}