定義： 定義： 定義一個用於創建對象的介面，讓子類決定實例化哪一個類。工廠方法使一個類的實例化延遲到其子類。 結構：（書中圖，侵刪） 一個工廠的抽象介面 若幹個具體的工廠類 一個需要創建對象的抽象介面 若幹個所需創建的對象的類 較之簡單工廠方法，多了一層抽象——將工廠也抽象了；由原來的一個萬能工廠變 ...
定義：
定義一個用於創建對象的介面，讓子類決定實例化哪一個類。工廠方法使一個類的實例化延遲到其子類。結構：（書中圖，侵刪）
導致的結果就是：原本新增一個要創建的對象需要直接修改萬能工廠類，增加判斷，違反了開放-封閉原則；
現在工廠相關代碼不用改，只需要新增工廠類即可，同時將判斷轉移給了客戶端。
實例：
既然是和簡單工廠相對比，就還是延用之前計算器的例子：（同樣，為了代碼簡潔不考慮輸入不合法等代碼健壯性） 抽象工廠介面：package designpattern.factorymethod; import designpattern.staticfactorymethod.Calculate; public interface CalculateFactory { Calculate create(); }若幹工廠介面： 加
package designpattern.factorymethod; import designpattern.staticfactorymethod.Calculate; import designpattern.staticfactorymethod.Plus; public class PlusFactory implements CalculateFactory{ @Override public Calculate create() { return new Plus(); } }
package designpattern.factorymethod; import designpattern.staticfactorymethod.Calculate; import designpattern.staticfactorymethod.Minus; public class MinusFactory implements CalculateFactory { @Override public Calculate create() { return new Minus(); } }減
package designpattern.factorymethod; import designpattern.staticfactorymethod.Calculate; import designpattern.staticfactorymethod.Multiply; public class MultiplyFactory implements CalculateFactory { @Override public Calculate create() { return new Multiply(); } }乘
package designpattern.factorymethod; import designpattern.staticfactorymethod.Calculate; import designpattern.staticfactorymethod.Divide; public class DivideFactory implements CalculateFactory { @Override public Calculate create() { return new Divide(); } }除
抽象計算類及若幹具體計算類：（延用之前簡單工廠方法的代碼） 抽象類：
package designpattern.staticfactorymethod; public abstract class Calculate { public double num1; public double num2; Calculate() { } Calculate(double num1, double num2) { this.num1 = num1; this.num2 = num2; } public abstract double calculate(); }
加：
package designpattern.staticfactorymethod; public class Plus extends Calculate { public Plus() { } Plus(double num1, double num2) { super(num1, num2); } @Override public double calculate() { return num1 + num2; } }
package designpattern.staticfactorymethod; public class Minus extends Calculate { public Minus() { } Minus(double num1, double num2) { super(num1, num2); } @Override public double calculate() { return num1 - num2; } }減
package designpattern.staticfactorymethod; public class Multiply extends Calculate { public Multiply() { } Multiply(double num1, double num2) { super(num1, num2); } @Override public double calculate() { return num1 * num2; } }乘
package designpattern.staticfactorymethod; public class Divide extends Calculate { public Divide() { } Divide(double num1, double num2) { super(num1, num2); } @Override public double calculate() { return num1 / num2; } }除 客戶端：
package designpattern.factorymethod; import java.util.Scanner; import designpattern.staticfactorymethod.Calculate; public class Client { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("請輸入一個數字"); double num1 = scanner.nextDouble(); System.out.println("請輸入一個運算符：+、-、*、/"); String operator = scanner.next();// 不能用nextLine()，會把上一個回車給吸收 System.out.println("請輸入一個數字"); double num2 = scanner.nextDouble(); CalculateFactory calculateFactory = null; switch (operator) { case "+": calculateFactory = new PlusFactory(); break; case "-": calculateFactory = new MinusFactory(); break; case "*": calculateFactory = new MultiplyFactory(); break; case "/": calculateFactory = new DivideFactory(); break; default: break; } Calculate calculate = calculateFactory.create(); calculate.num1 = num1; calculate.num2 = num2; System.out.println(calculate.calculate()); scanner.close(); } }
總結：
工廠方法模式就是在簡單工廠方法模式的基礎上進一步抽象，使其符合開放-封閉原則。 個人理解，在輕量級系統，或者工廠所能創建的東西較少可能修改的情況下，可以考慮使用簡單工廠模式； 否則，需要使用工廠方法模式。
