23种设计模式——简单工厂设计模式

Posted 2020-11-23 bm654

简单工厂模式

一、含义

简单工厂模式又被成为静态方法模式（因为在工厂类中定义了一个静态方法）。

二、简单工厂的基本步骤

创建抽象产品类(创建计算类operation类)或者接口

创建具体的产品类，继承或者实现相应的抽象产品类。

创建工厂类，通过创建静态方法根据传入不同的参数，从而创建不同的具体产品类实例。

三、使用简单工厂的实例

问题：实现一个计算器的功能。

package Golf;
?
import java.util.Scanner;
?
/**
 * @author bm
 * 计算器的实现--第一版
 */
class Caculate{
    public static void main(String[] args) {
        double result = 0;
        //创建Scanner对象，接受从控制台输入
        Scanner input=new Scanner(System.in);
        System.out.println("请输入第一个数：");
        String numA = input.next();
        System.out.println("请输入运算符(+、-、*、/)");
        String operater = input.next();
        System.out.println("请输入第二个数：");
        String numB = input.next();
        switch(operater){
            case "+":
                result = Double.parseDouble(numA) + Double.parseDouble(numB);
                break;
            case "-":
                result = Double.parseDouble(numA) - Double.parseDouble(numB);
                break;
            case "*":
                result = Double.parseDouble(numA) + Double.parseDouble(numB);
                break;
            case "/":
                if(Double.parseDouble(numB) != 0){
                    result = Double.parseDouble(numA) + Double.parseDouble(numB);
                    break;
                }else{
                    System.out.println("被除数不能为0！");
                }
?
        }
        System.out.println("结果为："+result);
?
    }
}

这样实现了计算器的功能，但是耦合度高，业务逻辑和界面耦合度高。复用性差，如果想要修改功能或者添加功能，很麻烦。一个对象的功能要单一，不要有多重作用。

运用面向对象的思想，将计算器分为两部分，一部分进行逻辑的运算，一部分进行页面的展示。

package com.golf.test;
?
/**
 * @author bm
 *  计算器--第二版 业务逻辑部分（计算的过程）
 */
public class Operation {
    public static double GetResult(String numA,String numB,String operater){
        double result = 0;
        switch(operater){
            case "+":
                result = Double.parseDouble(numA) + Double.parseDouble(numB);
                break;
            case "-":
                result = Double.parseDouble(numA) - Double.parseDouble(numB);
                break;
            case "*":
                result = Double.parseDouble(numA) + Double.parseDouble(numB);
                break;
            case "/":
                if(Double.parseDouble(numB) != 0){
                    result = Double.parseDouble(numA) + Double.parseDouble(numB);
                    break;
                }else{
                    System.out.println("被除数不能为0！");
                }
        }
        return  result;
    }
}
?

package com.golf.test;
?
import java.util.Scanner;
?
/**
 * 计算器的展示界面
 */
public class CaculateShow {
    public static void main(String[] args) {
        //创建Scanner对象，接受从控制台输入
        Scanner input=new Scanner(System.in);
        System.out.println("请输入第一个数：");
        String numA = input.next();
        System.out.println("请输入运算符(+、-、*、/)");
        String operater = input.next();
        System.out.println("请输入第二个数：");
        String numB = input.next();
        double result = Operation.GetResult(numA, numB, operater);
        System.out.println("结果为："+result);
    }
}
?

使用了面向对象的思想后，将计算器的业务逻辑和展示界面进行分离。但是不方便进行添加新的功能。譬如，我想要添加开根(sqrt)的功能，就要在Operation类的switch分支上进行添加相应的功能，这样一个不慎会对原来良好的代码产生影响。

我们倘若使用简单工厂模式呢？创建相应的抽象类operation，相应的功能创建具体的类继承抽象类Operation，在通过创建一个工厂类，按照用户的需求通过工厂类创建相应的运算类进行运算。

 

package com.golf.test2;
/**
*抽象类
**/
public class Operation {
   private String numA;
   private String numB;
   private double result;
?
    public String getNumA() {
        return numA;
    }
?
    public void setNumA(String numA) {
        this.numA = numA;
    }
?
    public String getNumB() {
        return numB;
    }
?
    public void setNumB(String numB) {
        this.numB = numB;
    }
?
    public double getResult(String numA, String numB){
        return  result;
    }
?
    public double getResult() {
        return result;
    }
?
    public void setResult(double result) {
        this.result = result;
    }
}
?

加法类

package com.golf.test2;
?
/**
 * 加法运算
 */
public class OperationAdd extends Operation{
?
?
    public double getResult(String numA,String numB){
?
        double result = Double.parseDouble(numA) + Double.parseDouble(numB);
        return  result;
    }
}
?

减法类

package com.golf.test2;
?
/**
 * 加法运算
 */
public class OperationSub extends Operation{
?
?
    public double getResult(String numA,String numB){
        double result = Double.parseDouble(numA) - Double.parseDouble(numB);
        return  result;
    }
}

如果有需要其他的运算符，创建相应的类去继承抽象类就行。

package com.golf.test2;
?
/**
 * 计算器的工厂类    （工厂类的创建对象方法一般用static进行修饰，这样不必去创建对象，返回值就是抽象类）
 */
public class OperationFactory {
    public static Operation createOperation(String operater){
        Operation operation = null;
        switch (operater){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
        }
        return operation;
    }
}
?

package com.golf.test2;
?
import java.util.Scanner;
?
/**
 * 计算器的页面展示
 */
public class OperationShow {
    public static void main(String[] args) {
        Operation operation = null;
        operation= OperationFactory.createOperation("+");
        Scanner input=new Scanner(System.in);
        System.out.println("请输入第一个数：");
        String numA = input.next();
        System.out.println("请输入第二个数：");
        String numB = input.next();
        operation.setNumA(numA);
        operation.setNumB(numB);
        double result =  operation.getResult(operation.getNumA(),operation.getNumB());
        System.out.println("结果为："+result);
    }
}
?

这样就是一个很好的简单工厂模式的代码，倘若我们需要更改加法运算，那么我们去修改OperationAdd类就行，倘若我们想要加相应的运算。那么我们创建相应的类去继承抽象类Operation，并且在工厂类OperationFactory中进行添加创建相应的类就行。

二、简单工厂模式的优缺点

优点：

可以根据外界给定的信息(参数)，交给工厂类去创建那个具体的对象。避免了直接去创建具体对象，使用者通过工厂类便可以使用相应的对象，不需要去管对象如何创建的。有利于软件体系结构的优化。

缺点：

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部的对象创建逻辑放在一个工厂类中，这样创建的类只能事先进行考虑到，倘若要创建新的类需要频繁的修改工厂类。然而当具体产品类不断的增多时，根据不同的条件创建不同实体类，这样会使得工厂类的逻辑越来越复杂。

简单工厂模式这些缺点，在工厂模式中得到了一定程度上的克服。