學習設計模式之 ：簡單工廠設計模式

之前瞭解過工廠設計模式，但是長時間沒有去複習，

導致又忘記了，所以打算每學習一個瞭解一個模式，就自己來敲一個用例來記錄一下。

這裏就沒有加註釋了 ，所以註釋都在代碼中

這是使用一個計算的方式

package com.design.model.factoryPattern;
/**
 *   簡單工廠設計模式
 */

import java.math.BigDecimal;

/**
 *  計算 接口
 */
public interface Calculate {
    /**
     *    運算方法
     * @return 運算結果
     */
    BigDecimal operation();
}

    這是是具體的實現類

package com.design.model.factoryPattern;

import com.util.TypeConvert;

import java.math.BigDecimal;

/**
 *  實現了計算接口
 *      實現接口的運算方法
 *      定義對應的運算方式
 */
public class DivideOperation implements Calculate {

    /**
     *   在 計算接口中 ，並沒有去定義參數
     *      但是在運算過程中 是必須要有 計算的參數才能運行
     *      我們定義一個參數類 {@code FactoryPojo} 對象
     *      通過設配器模式 來引入進來參數對象 進行運算
     */
    private FactoryPojo factoryPojo;

    public DivideOperation(FactoryPojo factoryPojo) {
       this.factoryPojo = factoryPojo;
    }

    /**
     *  除法 運算
     * @return 運算結果
     */
    @Override
    public BigDecimal operation() {
        BigDecimal divide = null;
        try {
            String number = factoryPojo.getNumber();
            System.out.println("除數：" + number);
            String passivenessNumber = factoryPojo.getPassivenessNumber();
            System.out.println("被除數：" + passivenessNumber);
            int retainNumber = factoryPojo.getRetainNumber();
            System.out.println("保留小數：" + retainNumber);
            divide = divideOperation(number, passivenessNumber, retainNumber);
        }catch (NumberFormatException e){
            System.err.println("除法參數不能有非數字字符串");
            e.printStackTrace();
        }catch (ArithmeticException e){
            System.err.println("除法參數不能爲 0");
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }
        return divide;
    }

    /**err
     *  實際運算方法
     *  除法
     *      保留n位小數 (默認保留2位小數)
     *          默認 四捨五入
     * @param number 除數
     * @param passivenessNumber 被除數
     * @param retainNumber  保留幾位小數
     * @return 運算結果
     */
    public static BigDecimal divideOperation(String number,String passivenessNumber,int retainNumber){
        BigDecimal division = TypeConvert.StringShiftBigDecimal(number);
        BigDecimal passivityDivision = TypeConvert.StringShiftBigDecimal(passivenessNumber);
        BigDecimal divide = division.divide(passivityDivision, retainNumber, BigDecimal.ROUND_HALF_DOWN);
        return divide;
    }
}

package com.design.model.factoryPattern;

import com.util.TypeConvert;

import java.math.BigDecimal;

/**
 *  實現了計算接口
 *      實現接口的運算方法
 *      定義對應的運算方式
 */
public class MultiplyOperation  implements Calculate {

    /**
     *   在 計算接口中 ，並沒有去定義參數
     *      但是在運算過程中 是必須要有 計算的參數才能運行
     *      我們定義一個參數類 {@code FactoryPojo} 對象
     *     
     */
    private FactoryPojo factoryPojo;

    public MultiplyOperation(FactoryPojo factoryPojo) {
        this.factoryPojo = factoryPojo;
    }

    /**
     * 乘法 運算
     * @return 運算結果
     */
    @Override
    public BigDecimal operation() {
        BigDecimal multiply = null;
        try {
            String number = factoryPojo.getNumber();
            System.out.println("乘數："+number);
            String passivenessNumber = factoryPojo.getPassivenessNumber();
            System.out.println("被乘數："+passivenessNumber);
            int retainNumber = factoryPojo.getRetainNumber();
            System.out.println("保留小數："+retainNumber);
            multiply = multiplyOperation(number,passivenessNumber,retainNumber);
        }catch (NumberFormatException e){
            System.err.println("除法參數不能有非數字字符串");
            e.printStackTrace();
        }catch (ArithmeticException e){
            System.err.println("除法參數不能爲 0");
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }
        return multiply;
    }

    /**
     *  實際運算方法
     *  乘法
     *      保留n位小數 (默認保留2位小數)
     *          默認 四捨五入
     * @param multiplyNumber 除數
     * @param passivenessNumber 被除數
     * @param retainNumber  保留幾位小數
     * @return 運算結果
     */
    public static BigDecimal multiplyOperation(String multiplyNumber,String passivenessNumber,int retainNumber){
        BigDecimal multiply = TypeConvert.StringShiftBigDecimal(multiplyNumber);
        BigDecimal passivityDivision = TypeConvert.StringShiftBigDecimal(passivenessNumber);
        BigDecimal multiplyResult = multiply.multiply(passivityDivision);
        BigDecimal bigDecimal = multiplyResult.setScale(retainNumber,BigDecimal.ROUND_HALF_UP);
        return bigDecimal;
    }
}

下面是帶有運算參數的對象

package com.design.model.factoryPattern;

public class FactoryPojo {

    private String number;   //操作的數

    private String passivenessNumber;  // 被操作的數

    private int retainNumber = 2;  // 保留的小數


    public FactoryPojo(String number, String passivenessNumber, int retainNumber) {
        this.number = number;
        this.passivenessNumber = passivenessNumber;
        this.retainNumber = retainNumber;
    }

    public FactoryPojo() {
    }

    public int getRetainNumber() {
        return retainNumber;
    }

    public void setRetainNumber(int retainNumber) {
        this.retainNumber = retainNumber;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getPassivenessNumber() {
        return passivenessNumber;
    }

    public void setPassivenessNumber(String passivenessNumber) {
        this.passivenessNumber = passivenessNumber;
    }
}

工廠方法

package com.design.model.factoryPattern;

/**
 *   計算的工廠接口類 創建好
 *   實現工廠接口的具體工廠創建好
 *   接下來就到 我們具體來選擇工廠來執行我們需要的方法的時候了
 */
public class SelectOperationMode {

    /**
     *
     * @param mode 這是選擇具體的實現工廠的字符串
     * @param factoryPojo   封裝了要操作的參數的對象
     * @return  指向了 實現了工廠接口的 具體實現的{@code Calculate} 此處引用了三大特性的 多態
     */
    public static Calculate selectMode(String mode,FactoryPojo factoryPojo){
        Calculate calculate = null;
        switch (mode){
           case  "divide":
                calculate = new DivideOperation(factoryPojo);
                break;
           case  "multiply":
                calculate = new MultiplyOperation(factoryPojo);
               break;
        }
        return calculate;
    }

    /**
     *  封裝了參數對象 {@code FactoryPojo} 的 靜態方法
     * @param number  操作參數
     * @param passivenessNumber 被操作的參數
     * @param retainNumber 保留的小數
     * @return  返回了 一個 封裝好了的 @code FactoryPojo}對象
     */
    public static FactoryPojo operationParameter(String number,String passivenessNumber,String retainNumber){
        int code = 2;
        if (retainNumber != null){
            code = Integer.parseInt(retainNumber);
        }
        return new FactoryPojo(number, passivenessNumber, code);
    }

    /**
     *  封裝了參數對象 {@code FactoryPojo} 的 靜態方法
     *      默認保留了2位小數
     * @param number  操作參數
     * @param passivenessNumber 被操作的參數
     * @return  返回了 一個 封裝好了的 @code FactoryPojo}對象
     */
    public static FactoryPojo operationParameter(String number,String passivenessNumber){
        return new FactoryPojo(number, passivenessNumber, 2);
    }
}

運行

package com.design.model.factoryPattern;

import java.math.BigDecimal;

public class main {
    public static void main(String[] args) {
        FactoryPojo factoryPojo = SelectOperationMode.operationParameter("201", "2");
        Calculate divide = SelectOperationMode.selectMode("divide", factoryPojo);
        BigDecimal operation = divide.operation();
        System.out.println(operation);

    }
}

工具類

package com.util;


import java.math.BigDecimal;

/**
 * BigDecimal 轉換操作
 */
public class TypeConvert {


    /**
     * 轉換
     * @param str
     * @return
     */
    public static BigDecimal StringShiftBigDecimal(String str){
        BigDecimal bigDecimal = new BigDecimal(str);
        return bigDecimal;
    }
}