設計模式(一):簡單工廠模式

描述

最近整理一些JAVA的基礎的知識。

簡單工廠模式，也就是說到底要實例化誰，將來會不會增加實例化的對象，比如計算演算法的實現過程中，需要減加乘除得類，以後說不定還會增加開根運算等，所以應該考慮單獨用一類來創造這個實力過程。

實現

為此我們就用簡單工廠類實現加減乘除的演算法計算。首先定義一個運算的介面。

public interface Operation {

    public double getResult();

}

定義好介面後，我們需要實現該介面，目前只實現加減乘除，所以需要四個實現類，在實現實現類之前，我們實現一個骨架抽象類，為了更靈活使用。

public abstract class AbstractOper implements Operation{

    protected double numA;
    protected double numB;

    protected AbstractOper(double numA, double numB) {
        this.numA = numA;
        this.numB = numB;
    }
    //運算抽象類
    protected abstract double oper();
    //實現介面的獲取運算結果的方法
    public double getResult() {
        return oper();
    }
}

然後開始編寫實現類，首先加法運算實現類

public class AddOperation extends AbstractOper implements Operation {


    public AddOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper() {
        return numA+numB;
    }
}

減法實現類

public class SubOperation extends AbstractOper implements Operation {
    public SubOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper() {
        return numA-numB;
    }
}

乘法實現類

public class MulOperation extends AbstractOper implements Operation {
    public MulOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper() {
        return BigDecimal.valueOf(numA).multiply(BigDecimal.valueOf(numA)).doubleValue();
    }
}

除法實現類，這裡要註意除數不為0問題

public class DivOperation extends AbstractOper implements Operation {
    public DivOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper(){
        try {
            if(numB==0){
                throw new Exception("除數不能為0");//這裡拋出異常
            }
        }catch (Exception e){
            System.out.println("除數不能為0");//我這為了方便就直接捕獲了,可以直接拋出
            return 0;
        }
        return BigDecimal.valueOf(numA).divide(BigDecimal.valueOf(numB)).doubleValue();
    }
}

當四個演算法運算類實現好，為了能夠方便具體實現哪一個類，所以建立一個工廠類

public class OperationFactory {

    public static Operation createOperation(String oper, double numA, double numB){
        Operation operation = null;
        switch (oper){
            case "+" :{
                operation = new AddOperation(numA,numB);
                break;
            }
            case "-" :{
                operation = new SubOperation(numA,numB);
                break;
            }
            case "*" :{
                operation = new MulOperation(numA,numB);
                break;
            }
            case "/" :{
                operation = new DivOperation(numA,numB);
                break;
            }

            default:{
                break;
            }
        }

        return operation;
    }
}

最後只要在客戶端調用工廠類即可創建具體實例，否在全在客戶端實現比較混亂也不利於維護

public class OperTest {
    public static void main(String[] args) {
        System.out.print("輸入numA:");
        Scanner scan = new Scanner(System.in);
        String readA = scan.nextLine();
        double numA = Double.parseDouble(readA);
        System.out.print("輸入numB:");
        String readB = scan.nextLine();
        double numB = Double.parseDouble(readB);
        System.out.print("輸入oper:");
        String operStr = scan.nextLine();
        //調用工廠類創建實例
        Operation oper = OperationFactory.createOperation(operStr,numA,numB);
        //調用獲取結果的方法
        double reslut = oper.getResult();
        System.out.println("輸入numA:"+numA+"輸入numB:"+numB+"輸出結果："+reslut);
    }
}

總結

最終通過簡單工廠實現了減加乘除得運算，好的程式離不開好的設計，雖然一個類也許就可以實現這泄功能，但那隻是面向過程而非面向對象，通過以上寫法用來滿足類的單一原則，里氏原則，開閉原則，介面隔離，最少知道原則，以更好地實現松耦合。