工廠方法模式

1 工廠模式介紹

　　1.1 定義：定義一個用於創建對象的接口，讓子類絕對實例化哪一個類，工廠方法使一個類的實例化延遲到其子類。

　　工廠方法模式通用類圖：

　　在工廠模式中，抽象產品類Product負責定義產品的共性，實現對事物最抽象的定義，Creator為抽象類創建類，也就是抽象工廠，具體如何創建產品類是有具體的實現工廠ConcreteCreator完成的。

　　1.2 工廠方法模式的優點

• 良好的封裝性，代碼結構清晰。
• 擴展性非常優秀，在增加產品類的情況系下，只有適當的修改具體的工廠類或擴展一個工廠類，就可以“擁抱變化”。
• 屏蔽產品類。產品類的實現如何變化，調用者無需關心，它只需關心產品的接口，只要接口保持不變，系統中的上層模塊就不需要發生變化。
• 解耦框架。高層模塊只需要知道產品的抽象類，其他實現類都不用關心。

　　1.3 工廠方法模式的使用場景

2 工廠模式實現

2.1 簡單工廠模式（靜態工廠模式）

　　以實現一個計算器為例：

　　整個過程涉及到三個對象，人（Program4類表示）、計算器（以OperationFactory類表示）、計算方式（計算方式中有多種，加減乘除等，但都屬於計算方法，以一個父類Operation，加減乘除繼承覆寫方法即可）。整個示例類如下圖：

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

            System.out.println ("請輸入數字A：");
            double numberA = Double.parseDouble (scanner.nextLine ());
            System.out.println ("選擇運算符(+、-、*、/):");
            String strOperate = scanner.nextLine ();
            System.out.println ("請輸入數字B：");
            double numberB = Double.parseDouble (scanner.nextLine ());
            String strResult = "";

            if ( strOperate != "/" || numberB != 0){
                Operation oper;
                oper = OperationFactory.createOperate (strOperate);
                oper.setNumberA (numberA);
                oper.setNumberB (numberB);
                
                strResult = String.valueOf (oper.getResult ());
                System.out.println ("結果為："+strResult);

            }else {
                System.out.println ("除數不能為零");
            }

            scanner.close ();
        } catch (Exception e) {
            throw new RuntimeException("您輸入有誤:"+e.getMessage ());
        }
    }
}

 計算器（工廠）根據用戶需求，選擇（生成）符合需要的計算方式創建對應的實例對象，創建過程中需要需用戶參與。

public class OperationFactory {
    public static Operation createOperate(String operate) {
        Operation oper = null;
        switch (operate){
            case "+":
                oper = new OperationAdd ();
                break;
            case "-":
                oper = new OperationSub ();
                break;
            case "*":
                oper = new OperationMul ();
                break;
            case "/":
                oper = new OperationDiv ();
                break;
        }
        return oper;
    }
}

public class Operation{
    private double numberA = 0;
    private double numberB = 0;

    public double getNumberA() { return numberA; }

    public void setNumberA(double numberA) { this.numberA = numberA; }

    public double getNumberB() { return numberB; }

    public void setNumberB(double numberB) { this.numberB = numberB; }

    public double getResult(){ 
        double result = 0;
        return result;
    }
}

class OperationAdd extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () + getNumberB ();
        return result;
    }
}

class OperationSub extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () - getNumberB ();
        return result;
    }
}

class OperationMul extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () * getNumberB ();
        return result;
    }
}

class OperationDiv extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () / getNumberB ();
        return result;
    }
}

 簡單工廠的缺點，不符合“開放封閉原則，要增加新的功能（計算方式）時，需要去修改工廠類（增加分支）。

2.2 多方法模式

是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字符串出錯，則不能正確創建對象，而多個工廠方法模式是提供多個工廠方法，分別創建對象。

public class OperationFactory03 {

    public Operation add(){
        return new OperationAdd();
    }

    public Operation sub(){
        return new OperationSub ();
    }

    public Operation mul(){
        return new OperationMul();
    }

    public Operation div(){
        return new OperationDiv();
    }
}

public class FactoryTest {

    public static void main(String[] args) {

        OperationFactory03 factory03 = new OperationFactory03();
        Operation add = factory03.add();
        
        add.setNumberA(20);
        add.setNumberB(10);
        double result = add.getResult();
        System.out.println(result);
    }
}

2.3 靜態工廠方法模式

多個工廠方法模式里的方法置為靜態的，不需要創建實例，直接調用即可。

public class OperationFactory {

    public static Operation add(){
        return new OperationAdd();
    }

    public static Operation sub(){
        return new OperationSub ();
    }

    public static Operation mul(){
        return new OperationMul();
    }

    public static Operation div(){
        return new OperationDiv();
    }
}

//調用類
public class FactoryTest {

    public static void main(String[] args) {

        Operation add = OperationFactory02.add();
        add.setNumberA(20);
        add.setNumberB(10);
        double result = add.getResult();
        System.out.println(result);
        
    }
}

　　總體來說，工廠模式適合：凡是出現了大量的產品需要創建，並且具有共同的接口時，可以通過工廠方法模式進行創建。在以上的三種模式中，第一種如果傳 入的字符串有誤，不能正確創建對象，第三種相對於第二種，不需要實例化工廠類，所以，大多數情況下，我們會選用第三種——靜態工廠方法模式。

3  抽象工廠模式

　　工廠方法模式有一個問題就是，類的創建依賴工廠類，也就是說，如果想要拓展程序，必須對工廠類進行修改，這違背了閉包原則，所以，從設計角度考慮， 有一定的問題，如何解決？就用到抽象工廠模式，創建多個工廠類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的代碼。因為抽象 工廠不太好理解，我們先看看圖，然后就和代碼，就比較容易理解。

接口類

public interface Sender {
    public void Send();
}

兩個實現類

public class MsgSender implements Sender{

    @Override
    public void Send() {
        System.out.println("this is msgsender");
    }
}

public class MailSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}

兩個工廠類

public class SendmsgFactory implements Provider {

    @Override
    public Sender produce() {
        return new MsgSender();
    }
}

public class SendmailFactory implements Provider {

    @Override
    public Sender produce() {
        return new MailSender();
    }
}

提供一個接口

public interface Provider {
    public Sender produce();
}

測試類

public class FactoryTest {
    public static void main(String[] args) {
        Provider provider = new SendmailFactory();
        Sender sender = provider.produce();
        sender.Send();
    }
}

　　其實這個模式的好處就是，如果你現在想增加一個功能：發及時信息，則只需做一個實現類，實現Sender接口，同時做一個工廠類，實現Provider接口，就OK了，無需去改動現成的代碼。這樣做，拓展性較好，即依賴抽象不依賴具體原則的體現。