Java-简单工厂模式

Posted 2021-08-15 小女子不才~~

前记：欠下的迟早是要还的~~~还债第三篇~

  最近在工作中，由于提高了对代码的要求，要求提高代码的质量和可读性，以前在写代码的时候也没有关注过代码的抽象性，所以现在不得不重新复习一下设计模式。就从最简单的简单工厂模式开始吧，其他的设计模式，有时间了会再继续写博客补充。

    先从需求说起吧，

有这样一个需求，根据两个int类型的值 a 和 b ，还用传参传入的操作符号，来决定对这两个值进行什么操作。如果操作符传入的是 “+” ,则 返回a+b 结果，如果操作符是减号“-”，则返回 a-b 的结果。如果操作符是乘号“*”，返回 a* b的结果，以此类推，在此处我只用加和减两个来举例。

菜鸟写法：

package signModel.simpleFactory.ordinary;

import org.junit.Test;

/**
 * @description:简单工厂模式
 * @createTime:2021/7/8 15:56
 * @version:1.0
 */
public class simpleFactory {
    //简单工厂模式。需求：
    //两个数字，一个运算符（不固定），根据不同的运算符得到不同的结果。
    // 普通写法
    @Test
    public void proGram(){
       int numA=2;
       int numB =3;
       String operate="+";
        int result = Operation.getResult(numA, numB, operate);
        System.out.println("计算结果："+result);

    }
}
 class Operation{
    public static int getResult(int numA,int numB,String operate){
        int result=0;
        switch (operate){
            case "+":
                result=numA+numB;
                break;
            case "-":
                result=numA-numB;
                break;
            case "*":
                result=numA*numB;
                break;
        }
        return result;
    }
}

使用很多个case，嗯~~小白一看就董。

    这是每个case下边的逻辑处理比较简单，但是如果是比较复制的处理逻辑，那每个case下的逻辑处理岂不是要一大串代码，另一方面就是，如果说现在需要新加一个除法的方法，就需要再这个getResult方法中新加一段case代码，如果要再加其他的运算，就要继续加case...这样慢慢的会导致这个方法代码不好维护。

    这里不得不说一下设计模式六大原则：1、单一职责原则，实现类要职责单一；2、里氏替换原则，不要破坏继承体系；3、依赖倒置原则，要面向接口编程；4、接口隔离原则，在设计接口的时候要精简单一；5、迪米特原则，要降低耦合；6、开放封闭原则，要对扩展开放，对修改关闭。

    对于6大原则详细的介绍，以后博客会写。

     很明显，上边的代码不符合单一职责原则，也没有降低耦合性，也不符合开放封闭原则。

在这里使用最简单的简单工厂模式对上边的代码进行修改，

 简单工厂模式

   先简单介绍一下简单工厂模式：简单工厂模式的实质就是由一个工厂类根据传入的参数，动态决定应该创建哪一个操作类（这些操作类继承自同一个父类或接口）的实例。

该模式中包含的角色及其职责：

工厂（Factory）角色：它负责实现创建所有实例的内部逻辑。工厂类的创建操作类的方法（静态的）可以被外界直接调用，从而创建所需要的操作对象。

抽象操作（Operation）角色：简单工厂模式所创建的操作对象的父类，他负责描述所有实例所有的公共接口。

具体的操作角色：就是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

此例子对应的UML 如下：

 UML图对应代码

抽象操作（Operation）角色：Operation类

/**
 * @description: 总的操作父类
 * @createTime:2021/7/8 18:41
 * @version:1.0
 */
public class Operation {
    protected int numA;
    protected int numB;

    public int getNumA() {
        return numA;
    }

    public void setNumA(int numA) {
        this.numA = numA;
    }

    public int getNumB() {
        return numB;
    }

    public void setNumB(int numB) {
        this.numB = numB;
    }

    //公共方法
    public int getResult(){
        return 0;
    }
}

具体的操作角色：加法子类

/**
 * @description:加法子类，继承父类，重写父类的getResult方法
 * @createTime:2021/7/8 18:44
 * @version:1.0
 */
public class OperationAdd extends Operation {
    public int getResult(){
        return numA+numB;
    }
}

具体的操作角色：减法子类

/**
 * @description:
 * @createTime:2021/7/8 18:48
 * @version:1.0
 */
public class OperationSub extends Operation {
    public int getResult(){
        return numA-numB;
    }
}

工厂（Factory）角色：工厂类

/**
 * @description: 工厂类，根据传入的操作方法获取对应的对象。
 * @createTime:2021/7/8 18:50
 * @version:1.0
 */
public class OperationFactory {
    public static Operation createOperation(String operate){
        Operation  operation=null;
        switch (operate){
            case "+":
                operation=new  OperationAdd();
                break;
            case "-":
                operation= new OperationSub();
                break;
        }
        return operation;
    }
}

测试的主方法：

/**
 * @description:
 * @createTime:2021/7/8 18:53
 * @version:1.0
 */
public class OperationMain {
    public static void main(String[] args) {
        String operate="+";
        Operation operation = OperationFactory.createOperation(operate);
        operation.setNumA(2);
        operation.setNumB(5);
        int result = operation.getResult();
        System.out.println("计算结果："+result);
    }
}

后记：天道好轮回，苍天饶过谁~~~，欠下的迟早是要还的~~