Java-简单工厂模式

Posted 小女子不才~~

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java-简单工厂模式相关的知识,希望对你有一定的参考价值。

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

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

    先从需求说起吧,

有这样一个需求,根据两个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);
    

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

 

以上是关于Java-简单工厂模式的主要内容,如果未能解决你的问题,请参考以下文章

Java设计模式之简单工厂工厂方法和抽象工厂

Java中简单工厂模式,工厂模式,抽象工厂模式,策略模式和适配器模式学习

关于简单工厂模式工厂方法模式和抽象工厂模式的解析

java 工厂模式 从无到有-到简单工厂模式-到工厂方法模式-抽象工厂模式

java设计模式 - 工厂模式

带领大家一起进“厂”Java简单工厂+工厂方法+抽象工厂