工廠模式——Java實現

1.簡單工廠

目的：

在創建一個對象時不向客戶暴露內部細節，並提供一個創建對象的通用接口。

原理：

簡單工廠把實例化的操作單獨放到一個類中，這個類就成爲簡單工廠類，讓簡單工廠類來決定應該用哪個具體子類來實例化。

這樣做能把客戶類和具體子類的實現解耦，客戶類不再需要知道有哪些子類以及應當實例化哪個子類。客戶類往往有多個，如果不使用簡單工廠，那麼所有的客戶類都要知道所有子類的細節。而且一旦子類發生改變，例如增加子類，那麼所有的客戶類都要進行修改。

個人通俗解釋：

就是把switch-case封裝起來，使得程序滿足面向對象封裝特性。
做個共同接口統一管理一下。

實現：

public interface Product {
}
public class ConcreteProduct implements Product {
}
public class ConcreteProduct1 implements Product {
}
public class ConcreteProduct2 implements Product {
}

以下的 Client 類包含了實例化的代碼，這是一種錯誤的實現。如果在客戶類中存在這種實例化代碼，就需要考慮將代碼放到簡單工廠中。

public class Client {

    public static void main(String[] args) {
        int type = 1;
        Product product;
        if (type == 1) {
            product = new ConcreteProduct1();
        } else if (type == 2) {
            product = new ConcreteProduct2();
        } else {
            product = new ConcreteProduct();
        }
        // do something with the product
    }
}

以下的 SimpleFactory 是簡單工廠實現，它被所有需要進行實例化的客戶類調用。

public class SimpleFactory {

    public Product createProduct(int type) {
        if (type == 1) {
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}
public class Client {

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Product product = simpleFactory.createProduct(1);
        // do something with the product
    }
}

2.工廠方法

目的：

定義了一個創建對象的接口，但由子類決定要實例化哪個類。工廠方法把實例化操作推遲到子類。

原理：

在簡單工廠中，創建對象的是另一個類，而在工廠方法中，是由子類來創建對象。

Factory 有一個 doSomething() 方法，這個方法需要用到一個產品對象，這個產品對象由 factoryMethod() 方法創建。該方法是抽象的，需要由子類去實現。

個人通俗解釋：

利用繼承，代替switch-case
進一步解耦合，延遲具體對象實例化（不用實現同一個接口了）

實現：

public abstract class Factory {
    abstract public Product factoryMethod();
    public void doSomething() {
        Product product = factoryMethod();
        // do something with the product
    }
}
public class ConcreteFactory extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}
public class ConcreteFactory1 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct1();
    }
}
public class ConcreteFactory2 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct2();
    }
}

3. 抽象工廠

目的：

提供一個接口，用於創建相關的對象家族。

原理：

抽象工廠模式創建的是對象家族，也就是很多對象而不是一個對象，並且這些對象是相關的，也就是說必須一起創建出來。而工廠方法模式只是用於創建一個對象，這和抽象工廠模式有很大不同。

抽象工廠模式用到了工廠方法模式來創建單一對象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是讓子類來實現，這兩個方法單獨來看就是在創建一個對象，這符合工廠方法模式的定義。

至於創建對象的家族這一概念是在 Client 體現，Client 要通過 AbstractFactory 同時調用兩個方法來創建出兩個對象，在這裏這兩個對象就有很大的相關性，Client 需要同時創建出這兩個對象。

從高層次來看，抽象工廠使用了組合，即 Cilent 組合了 AbstractFactory，而工廠方法模式使用了繼承。

個人通俗解釋：

大廠SDK才用的吧，場景是同一個產品需要不同的實現。
比如：a國的麥樂雞和c國的麥樂雞不一樣，我真是舉例鬼才

實現：

public class AbstractProductA {
}
public class AbstractProductB {
}
public class ProductA1 extends AbstractProductA {
}
public class ProductA2 extends AbstractProductA {
}
public class ProductB1 extends AbstractProductB {
}
public class ProductB2 extends AbstractProductB {
}
public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}
public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}
public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        AbstractProductA productA = abstractFactory.createProductA();
        AbstractProductB productB = abstractFactory.createProductB();
        // do something with productA and productB
    }
}