大話設計模式讀書筆記系列-5.工廠方法

>>>大話設計模式讀書筆記系列目錄>>>

工廠方法

定義一個用於建立對象的接口,讓子類決定實例化哪個類。工廠方法使一個類的實例化延遲到其子類。

場景：

經過計算器（加減乘除）來說解工廠方式

 

 

計算器運算抽象類

/**
 * 計算器運算抽象類
 */
public abstract class Operation {
    /**
     * 操做數A
     */
    private double numberA;
    /**
     * 操做數B
     */
    private double numberB;

    /**
     * 抽象方法
     * 得到操做結果
     *
     * @return
     */
    public abstract double getResult();

    /**
     * 獲取 操做數A
     *
     * @return numberA 操做數A
     */
    public double getNumberA() {
        return this.numberA;
    }

    /**
     * 設置 操做數A
     *
     * @param numberA 操做數A
     */
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    /**
     * 獲取 操做數B
     *
     * @return numberB 操做數B
     */
    public double getNumberB() {
        return this.numberB;
    }

    /**
     * 設置 操做數B
     *
     * @param numberB 操做數B
     */
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    @Override
    public String toString() {
        return "Operation{" +
                "numberA=" + numberA +
                ", numberB=" + numberB +
                '}';
    }
}

 

加法運算類

/**
 * 加法運算類
 */
public class OperationAdd extends Operation {

    @Override
    public double getResult() {
        return super.getNumberA() + super.getNumberB();
    }
}

 

減法運算類

/**
 * 減法運算類
 */
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return super.getNumberA() - super.getNumberB();
    }
}

 

乘法運算類

/**
 * 乘法運算類
 */
public class OperationMul extends Operation {
    @Override
    public double getResult() {
        return super.getNumberA() * super.getNumberB();
    }
}

 

除法運算類

/**
 * 除法運算類
 */
public class OperationDiv extends Operation {
    @Override
    public double getResult() {
        return super.getNumberA() / super.getNumberB();
    }
}

 

工廠接口

/**
 * 工廠接口
 */
public interface IFactory {
    Operation createOperation();
}

 

加法工廠實現類

/**
 * 加法工廠實現類
 */
public class AddFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}

 

減法工廠實現類

/**
 * 減法工廠實現類
 */
public class SubFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }
}

 

乘法工廠實現類

/**
 * 乘法工廠實現類
 */
public class MulFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationMul();
    }
}

 

除法工廠實現類

/**
 * 除法工廠實現類
 */
public class DevFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationDiv();
    }
}

 

調用

/**
 * 部分代碼參照簡單工廠demo
 * 工廠模式
 */
public class FactoryMethodDemo {
    public static void main(String[] args) {
        IFactory operFactory;
        Operation oper;
        double result;
        //建立加法工廠
        operFactory=new AddFactory();
        //得到加法運算器
        oper=operFactory.createOperation();
        oper.setNumberA(1);
        oper.setNumberB(2);
        //得到結果
        result=oper.getResult();
        System.out.println("加法計算結果:"+String.valueOf(result));

        //建立乘法工廠
        operFactory=new MulFactory();
        //得到加法運算器
        oper=operFactory.createOperation();
        oper.setNumberA(1);
        oper.setNumberB(2);
        //得到結果
        result=oper.getResult();
        System.out.println("乘法計算結果:"+String.valueOf(result));

        //建立除法工廠
        operFactory=new DevFactory();
        //得到加法運算器
        oper=operFactory.createOperation();
        oper.setNumberA(1);
        oper.setNumberB(2);
        //得到結果
        result=oper.getResult();
        System.out.println("除法計算結果:"+String.valueOf(result));

        //建立減法工廠
        operFactory=new SubFactory();
        //得到加法運算器
        oper=operFactory.createOperation();
        oper.setNumberA(1);
        oper.setNumberB(2);
        //得到結果
        result=oper.getResult();
        System.out.println("減法計算結果:"+String.valueOf(result));

    }
}

 

結果

加法計算結果:3.0
乘法計算結果:2.0
除法計算結果:0.5
減法計算結果:-1.0

 

解析

簡單工廠模式的最大優勢在於工廠類中包含了必要的邏輯判斷,根據客戶端的選擇條件動態實例化相關的類,對於客戶端來講,去除了與具體產品的依賴.

工廠方法模式實現時,客戶端須要決定實例化哪個工廠來實現運算類,選擇判斷的問題仍是存在的,也就是說,工廠方法把簡單工廠的內部邏輯判斷移到了客戶端代碼來進行,你想要加功能,原本是改工廠類的,而如今是修改客戶端.