【設計模式】工廠模式-5

工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。
在工廠模式中，我們在創建對象時不會對客戶端暴露創建邏輯，並且是通過使用一個共同的接口來指向新創建的對象。

工廠模式介紹（來自菜鳥教程）

意圖：
定義一個創建對象的接口，讓其子類自己決定實例化哪一個工廠類，工廠模式使其創建過程延遲到子類進行。

主要解決：
主要解決接口選擇的問題。

何時使用：
我們明確地計劃不同條件下創建不同實例時。

如何解決：
讓其子類實現工廠接口，返回的也是一個抽象的產品。

關鍵代碼：
創建過程在其子類執行。

**應用實例： **
1、您需要一輛汽車，可以直接從工廠裏面提貨，而不用去管這輛汽車是怎麼做出來的，以及這個汽車裏面的具體實現。
2、Hibernate 換數據庫只需換方言和驅動就可以。

優點：
1、一個調用者想創建一個對象，只要知道其名稱就可以了。
2、擴展性高，如果想增加一個產品，只要擴展一個工廠類就可以。
3、屏蔽產品的具體實現，調用者只關心產品的接口。

缺點：
每次增加一個產品時，都需要增加一個具體類和對象實現工廠，使得系統中類的個數成倍增加，在一定程度上增加了系統的複雜度，同時也增加了系統具體類的依賴。這並不是什麼好事。

使用場景：
1、日誌記錄器：記錄可能記錄到本地硬盤、系統事件、遠程服務器等，用戶可以選擇記錄日誌到什麼地方。
2、數據庫訪問，當用戶不知道最後系統採用哪一類數據庫，以及數據庫可能有變化時。 3、設計一個連接服務器的框架，需要三個協議，“POP3”、“IMAP”、“HTTP”，可以把這三個作爲產品類，共同實現一個接口。

注意事項：
作爲一種創建類模式，在任何需要生成複雜對象的地方，都可以使用工廠方法模式。有一點需要注意的地方就是複雜對象適合使用工廠模式，而簡單對象，特別是只需要通過 new 就可以完成創建的對象，無需使用工廠模式。如果使用工廠模式，就需要引入一個工廠類，會增加系統的複雜度。

工廠模式實戰

老夫在參加校招的時候，忘了是哪個公司，先參加筆試，筆試內容是 Java/C 任意選擇一個開發語言作爲我們筆試的基本語言。因爲老夫對 C 向來沒興趣，就選擇了 Java . 在筆試題中 ， 有一道題目是使用 面嚮對象語言 Java 編寫一個可實現 加 / 減 / 乘 / 除 基本功能的簡易計算器。這看起來還是很簡單的。所以老夫就隨手寫了，按照順序寫的，就跟 C 一樣。

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in) ;
        while (true){
            System.out.println("請輸入數字 A ： ");
            int numA = scanner.nextInt();
            System.out.println("輸入操作符： ");
            String operator = scanner.next();
            System.out.println("輸入數字 B ： ");
            int numB = scanner.nextInt();

            int result = operate(numA, operator, numB);

            System.out.println("計算後的結果爲: "   result);
        }
    }

    public static int operate(int numA , String operator , int numB){
        switch (operator){
            case " " :
                return (numA   numB) ;
            case "-":
                return (numA - numB) ;
            case "*":
                return (numA * numB) ;
            case "/":
                if (numB == 0){
                    throw new IllegalArgumentException("除數不可爲 0") ;
                }else {
                    return (numA / numB) ;
                }
            default:
                throw new IllegalArgumentException("nothing ... ") ;
        }
    }
}

後來，面試官拿到我的筆試題，前面的都沒看，看到我的程序，就問我，你覺得你的程序有什麼問題？然後我說，功能都沒問題呀，好像沒啥別的毛病。面試官跟我說：“你的功能是實現了，但是你有沒有看到要求。用面嚮對象語言 Java 來實現，你實現了這個功能，但面向對象沒有體現出來。你覺得怎麼去改它。”後來面試官應該看不下去了，就跟我說：“簡單點，你把這個業務代碼和這個界面分離，這個你能做到吧。”後來我改成了下面的這個：

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in) ;
        while (true){
            System.out.println("請輸入數字 A ： ");
            int numA = scanner.nextInt();
            System.out.println("輸入操作符： ");
            String operator = scanner.next();
            System.out.println("輸入數字 B ： ");
            int numB = scanner.nextInt();

            int result = Operator.operate(numA, operator, numB);

            System.out.println("計算後的結果爲: "   result);
        }
    }

    
}

class Operator{
    public static int operate(int numA , String operator , int numB){
        switch (operator){
            case " " :
                return (numA   numB) ;
            case "-":
                return (numA - numB) ;
            case "*":
                return (numA * numB) ;
            case "/":
                if (numB == 0){
                    throw new IllegalArgumentException("除數不可爲 0") ;
                }else {
                    return (numA / numB) ;
                }
            default:
                throw new IllegalArgumentException("nothing ... ") ;
        }
    }
}

然後他跟我說：“你這樣寫，不就分開了嗎。”後來我們就聊了下入職實習等一些情況。講真的，當時我是真沒覺得這有啥子區別，我就換個位置而已。後來才知道，分開之後相當於解耦的過程。上述的過程其實相當於一個封裝的過程。將操作部分封裝在一個類裏面。

工廠模式下的調整

首先，我們先將上面的程序在重構一下，上面的耦合性太高，再解耦。
這是新的 Operator.java

public abstract class Operator {
    public int numA ;
    public int numB ;


    public int getNumA() {
        return numA;
    }

    public void setNumA(int numA) {
        this.numA = numA;
    }

    public int getNumB() {
        return numB;
    }

    public void setNumB(int numB) {
        this.numB = numB;
    }

    public abstract int getResult();
}

OperatorAdd.java

public class OperatorAdd extends Operator {

    @Override
    public int getResult() {
        return numA   numB;
    }
}

OperatorFactory.java

public class OperatorFactory {

    public static Operator createOperatorFactory(String operate){
        switch (operate){
            case " " :
                return new OperatorAdd() ;
            case "-":
                return new OperatorSub() ;
            case "*":
                return new OperatorMul() ;
            case "/":
                return new OperatorDiv() ;
            default:
                throw new IllegalArgumentException("Are you kidding ? ") ;
        }
    }
}

在工廠類中，OperatorSub.java , OperatorMul.java , OperatorDiv.java 與 OperatorAdd.java 相似。

現在再看主類：

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in) ;

        System.out.println("請輸入數字 A ： ");
        int numA = scanner.nextInt();
        System.out.println("輸入操作符： ");
        String operate = scanner.next();
        System.out.println("輸入數字 B ： ");
        int numB = scanner.nextInt();

        Operator operator = OperatorFactory.createOperatorFactory(operate) ;
        operator.setNumA(numA);
        operator.setNumB(numB);
        int result = operator.getResult();
        System.out.println(result);

    }
}

以上便是一個很簡單的工廠模式。