三種工廠設計模式看這篇就夠了

前言

面試被提問到三種工廠模式 回答得十分模糊 因而花了一上午時間梳理並總結 ,爲了方便你們實踐,我把代碼都編寫在一個.java裏面,複製便可食用.寫完總結了一下,三種工廠設計模式產品和工廠對應關係相似,多對一,一對一,以及一對多

簡單工廠模式

首先介紹簡單工廠模式，它的主要特色是須要在工廠類中作判斷，從而創造相應的產品。當增長新的產品時，就須要修改工廠類。

舉個例子。有一家生產處理器核的廠家，它只有一個工廠，可以生產兩種型號的處理器核。客戶須要什麼樣的處理器核，必定要顯示地告訴生產工廠。下面給出一種實現方案。

流程圖:

測試表代碼

package sample;

//簡單工廠代碼demo
public class FactoryDemo {

    interface Product{
        public void saySmoe() ;
    }

    static class ProductA implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA");
        }
    }
    static class ProductB implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductB");
        }
    }

    static class ProductFactory{
        public static Product getProduct(String name) {
            if("productA".equals(name)) {
                return new ProductA();
            }else if("productB".equals(name)) {
                return new ProductB();
            }else {
                return null;
            }


        }
    }
    public static void main(String[] args) {
        // 使用工廠模式 下降使用者與被使用者之間的耦合
        //Product productA = new productA();
        // 將使用者與被使用者之間的依賴轉移到使用者與工廠之間的依賴
        Product productA = ProductFactory.getProduct("productA");
        if(null!=productA) {
            productA.saySmoe();
        }
    }
}

結果:

say ProductA

工廠模式

簡單工廠模式雖然方便,可是每次添加新的產品就須要修改工廠類。這就違反了開放封閉原則：軟件實體（類、模塊、函數）能夠擴展，可是不可修改。因而，工廠方法模式出現了。所謂工廠方法模式，是指定義一個用於建立對象的接口，讓子類決定實例化哪個類。Factory Method使一個類的實例化延遲到其子類。

流程圖:

測試表代碼

package sample;

//簡單工廠代碼demo
public class FactoryDemo {

    interface Product{
        public void saySmoe() ;
    }

    interface AbstarctFactory{
        Product getProduct();
    }

    static class ProductA implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA");
        }
    }
    static class ProductB implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductB");
        }
    }

    static class ProductFactoryA implements  AbstarctFactory{
        @Override
        public Product getProduct() {
            return new ProductA();
        }
    }

    static class ProductFactoryB implements  AbstarctFactory{
        @Override
        public Product getProduct() {
            return new ProductB();
        }
    }
    public static void main(String[] args) {
        AbstarctFactory productFactoryA = new ProductFactoryA();
        AbstarctFactory productFactoryB = new ProductFactoryB();
        productFactoryA.getProduct().saySmoe();
        productFactoryB.getProduct().saySmoe();

    }
}

抽象工廠模式

既然有了簡單工廠模式和工廠方法模式，爲何還要有抽象工廠模式呢？它到底有什麼做用呢？仍是舉這個例子，這家公司的技術不斷進步，不只能夠生產單核處理器，也能生產多核處理器。如今簡單工廠模式和工廠方法模式都鞭長莫及。抽象工廠模式登場了。它的定義爲提供一個建立一系列相關或相互依賴對象的接口，而無需指定它們具體的類。具體這樣應用，這家公司仍是開設兩個工廠，一個專門用來生產A型號的單核多核處理器，而另外一個工廠專門用來生產B型號的單核多核處理器

流程圖:

package sample;

//簡單工廠代碼demo
public class AbstractFactoryDemo {

    interface ProductA{
        public void saySmoe() ;
    }

    interface ProductB{
        public void eatFood() ;
    }

    interface AbstarctFactory{
        ProductA getProductA();
        ProductB getProductB();
    }

    static class ProductA1 implements ProductA{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA1");
        }
    }
    static class ProductA2 implements ProductA{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA2");
        }
    }
    static class ProductB1 implements ProductB{
        @Override
        public void eatFood() {
            System.out.println("say ProductB1");
        }
    }
    static class ProductB2 implements ProductB{
        @Override
        public void eatFood() {
            System.out.println("say ProductB2");
        }
    }

    static class ProductFactory1 implements  AbstarctFactory{

        @Override
        public ProductA getProductA() {
            return new ProductA1();
        }

        @Override
        public ProductB getProductB() {
            return new ProductB1();
        }
    }

    static class ProductFactory2 implements  AbstarctFactory{

        @Override
        public ProductA getProductA() {
            return new ProductA2();
        }

        @Override
        public ProductB getProductB() {
            return new ProductB2();
        }
    }
    public static void main(String[] args) {
        //構造一個製做 產品A1 和 產品B1的的工廠
        AbstarctFactory abstarctFactory1 = new ProductFactory1();
        abstarctFactory1.getProductA().saySmoe();
        abstarctFactory1.getProductB().eatFood();

        System.out.println("===================");
        //構造一個製做 產品A2 和 產品B2的的工廠
        AbstarctFactory abstarctFactory2 = new ProductFactory2();
        abstarctFactory2.getProductA().saySmoe();
        abstarctFactory2.getProductB().eatFood();
    }
}

結果:

say ProductA1
say ProductB1
===================
say ProductA2
say ProductB2

補一句,今天週六,你們注意休息🍻🍻🍻

要是能爲您提供幫助，請給予支持(關注、點贊、分享)，蟲蟲蟹蟹你們了！