学习设计模式之 ：简单工厂设计模式

之前了解过工厂设计模式，但是长时间没有去复习，

导致又忘记了，所以打算每学习一个了解一个模式，就自己来敲一个用例来记录一下。

这里就没有加注释了 ，所以注释都在代码中

这是使用一个计算的方式

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;
    }
}