工廠模式：工廠方法模式和抽象工廠模式

咱們常說的工廠模式並非一種具體的設計模式。在「GoF設計模式（23種經典設計模式）」裏，具體的「工廠模式」是指：工廠方法模式（Factory Method Pattern）和抽象工廠模式（Abstract Factory Pattern）。但咱們常把簡單工廠模式（Simple Factory Pattern）、工廠方法模式、抽象工廠模式統一稱爲工廠模式。

簡單工廠模式(Simple Factory Pattern)

簡單工廠也叫靜態工廠。簡單工廠模式並非一種設計模式，或者說它不在Gof概括的設計模式裏。它是咱們的一種設計方法。當咱們建立對象時，通常經過new的方式建立，而這種方式建立就是面向實現方式編程（當咱們對象已經肯定時，相關的功能就已經肯定了）。

使用簡單工廠模式建立對象的好處：

• 簡單方便獲取對象

• 可使建立對象的細節與業務代碼分割開來，封裝並隱藏對象建立的細節

• 建立對象的方式修改了，只須要修改工廠裏的方法，而不須要在每一個調用方修改。

簡單工廠方法實現起來，很是簡單：

// 抽象產品接口
public interface IProduct {
    void display();
}

複製代碼

//產品A
public class AProduct implements IProduct {
    @Override
    public void display() {
        System.out.println("我是A產品");
    }
}
複製代碼

// 產品B
public class BProduct implements IProduct {
    @Override
    public void display() {
        System.out.println("我是B產品");
    }
}
複製代碼

// 簡單工廠
public class SimpleFactory {
    public static IProduct createProduct(String type) {
        if ("A".equals(type)) {
            return new AProduct();
        }
        if ("B".equals(type)) {
            return new BProduct();
        }
        return null;
    }

    public static void main(String[] args) {
        // A產品
        IProduct aProduct = SimpleFactory.createProduct("A");
        aProduct.display();
        // B產品
        IProduct bProduct = SimpleFactory.createProduct("B");
        bProduct.display();
    }
}
輸出結果：
我是A產品
我是B產品
複製代碼

簡單工廠實現起來很簡單，但也有必定弊端，主要是違法了開閉原則（對擴展開放，對修改關閉），當須要增長新的產品時，咱們須要修改簡單工廠裏的靜態方法。

工廠方法模式（Factory Method Pattern）

工廠方法模式(Factory Method Pattern)：定義一個用於建立對象的接口，讓子類決定將哪個類實例化。工廠方法模式讓一個類的實例化延遲到其子類。

工廠方法模式包含四種角色：抽象產品，具體產品，抽象工廠，具體工廠

具體產品（具體對象），由具體工廠方法建立。

用代碼演示以下

// 抽象產品
public interface IProduct {
    void display();
}

複製代碼

//具體產品A
public class AProduct implements IProduct {
    @Override
    public void display() {
        System.out.println("我是A產品");
    }
}
複製代碼

// 具體產品B
public class BProduct implements IProduct {
    @Override
    public void display() {
        System.out.println("我是B產品");
    }
}
複製代碼

// 抽象工廠
public interface IProductFactory {
    IProduct createProduct();
}
複製代碼

// 具體工廠A
public class ProductAFactory implements IProductFactory {
    @Override
    public IProduct createProduct() {
        return new AProduct();
    }

}
複製代碼

// 具體工廠B
public class ProductBFactory implements IProductFactory {
    @Override
    public IProduct createProduct() {
        return new BProduct();
    }
}
複製代碼

// 客戶端演示
public class Client {
    public static void main(String[] args) {
        // A產品工廠
        IProductFactory aProductFactory = new ProductAFactory();
        // 建立A產品
        IProduct aProduct = aProductFactory.createProduct();
        aProduct.display();
        // B產品工廠
        IProductFactory bProductFactory = new ProductBFactory();
        // 建立B產品
        IProduct bProduct = bProductFactory.createProduct();
        bProduct.display();
    }
}
輸出結果：
我是A產品
我是B產品
複製代碼

若是咱們須要新增「產品C」，只須要增長一個「產品C」的實現類和「產品C」的具體工廠。

工廠方法模式相對簡單工廠方法來講，主要是實現了對修改關閉（若要修改，只須要新增一個子類）。

工廠方法模式中的「讓一個類的實例化延遲到其子類」，是增長系統擴展性的重要方式。

固然，從演示代碼來看，在添加新產品時，須要編寫新的具體產品類，並且還要提供與之對應的具體工廠類，系統中類的個數將成對增長，在必定程度上增長了系統的複雜度，有更多的類須要編譯和運行，會給系統帶來一些額外的開銷。

抽象工廠模式（Abstract Factory Pattern）

抽象工廠模式提供一個建立一系列相關或相互依賴對象的接口。

抽象工廠模式與工廠方法相似，都是經過具體工廠來建立具體產品。但抽象工廠不是創造一類產品（全部具體產品都是實現（繼承）同一個抽象產品，因此歸爲一類產品），而是建立一系列相關或相互依賴的產品。什麼是一系列或相互依賴的產品來講呢？舉一個現實中例子，冰箱是一類產品，實際有海爾冰箱、美的冰箱等。而一系列產品就是同一品牌下的不一樣產品，好比海爾系列的：海爾冰箱、海爾空調、海爾洗衣機；美的系列的：美的冰箱、美的空調、美的洗衣機。一般，一系列的產品也被稱爲「產品族」

用代碼演示抽象工廠演示以下：

// 抽象卡券
public interface ICard {
    void display();
}
複製代碼

// 抽象產品
public interface IProduct {
    void display();
}
複製代碼

// A系列產品
public class AProduct implements IProduct {
    @Override
    public void display() {
        System.out.println("我是A產品");
    }
}
複製代碼

// A系統卡券
public class ACard implements ICard {
    @Override
    public void display() {
        System.out.println("我是A卡券");
    }
}
複製代碼

// B系列產品
public class BProduct implements IProduct {
    @Override
    public void display() {
        System.out.println("我是B產品");
    }
}
複製代碼

// B系列卡券
public class BCard implements ICard {
    @Override
    public void display() {
        System.out.println("我是B卡券");
    }
}
複製代碼

// 抽象工廠，建立相互依賴或相關的產品
public interface AbstractFactory {
    /**
     * 建立商品
     * @return
     */
    IProduct createProduct();

    /**
     * 建立卡券
     * @return
     */
    ICard createCard();
}
複製代碼

// A系列工廠
public class AFactory implements AbstractFactory {
    @Override
    public IProduct createProduct() {
        return new AProduct();
    }

    @Override
    public ICard createCard() {
        return new ACard();
    }
}
複製代碼

// B系列工廠
public class BFactory implements AbstractFactory {
    @Override
    public IProduct createProduct() {
        return new BProduct();
    }

    @Override
    public ICard createCard() {
        return new BCard();
    }
}
複製代碼

// 客戶端
public class Client {
    public static void main(String[] args) {
        // A系統產品
        AbstractFactory aFactory = new AFactory();
        IProduct aProduct = aFactory.createProduct();
        ICard aCard = aFactory.createCard();
        aProduct.display();
        aCard.display();

        // B系列產品
        AbstractFactory bFactory = new BFactory();
        IProduct bProduct = bFactory.createProduct();
        ICard bCard = bFactory.createCard();
        bProduct.display();
        bCard.display();
    }
}

輸出結果：
我是A產品
我是A卡券
我是B產品
我是B卡券
複製代碼

抽象工廠能夠建立一系列產品，但其有一個弊端，在產品族中新增一個產品，其全部具體工廠，都須要從新實現一個建立新產品的方法。