java设计模式之简单工厂模式

 

一  简介

      简单工厂模式属于工厂模式的一种，工厂模式总共有三种，分别是简单工厂模式，工厂方法模式和抽象工厂模式。

二   以下以一个简单的例子介绍一下

简单工厂模式-计算机的实现
算法工厂类：通过传入不同的值，创建不同的算法对象

public class OperationFactory {
    public static Operation createOperation(String operate) {
        Operation oper = null;
        switch (operate) {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
            default:
                System.out.println("输入有误！");
                break;
        }
        return oper;
    }
}

运算类：父类，用于具体算法类继承

public class Operation {
    private double numberA;
    private double numberB;
    public double getNumberA() {
        return numberA;
    }
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }
    public double getNumberB() {
        return numberB;
    }
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }
    public double getResult() {
        double result = 0.0;
        return result;
    }
}

具体运算操作实现类：每一个不同的算法，都会有一个对应的操作类，该类都需要继承Operation方法，并重写getresult方法

public class OperationAdd extends Operation {//加法类
    @Override
    public double getResult() {
        double result = 0.0;
        result = getNumberA() + getNumberB();
        return result;
    }
}

public class OperationDiv extends Operation {//除法类
    @Override
    public double getResult() {
        double result = 0.0;
        if (getNumberB() != 0.0) {
            result = getNumberA() / getNumberB();
        } else {
            System.out.println("除数不能为0！");
        }
        return result;
    }
}

public class OperationMul extends Operation {//乘法类
    @Override
    public double getResult() {
        double result = 0.0;
        result = getNumberA() * getNumberB();
        return result;
    }
}

public class OperationSub extends Operation {//减法类
    @Override
    public double getResult() {
        double result = 0.0;
        result = getNumberA() - getNumberB();
        return result;
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要进行的计算（+ - / *）:");
        String operate = sc.next();
        while (!("+".equals(operate) || "-".equals(operate) || "*".equals(operate) || "/".equals(operate))) {
            System.out.println("输入的操作符不符合要求，请重新输入（+ - / *）:");
            operate = sc.next();
        }
        Operation operation = OperationFactory.createOperation(operate);
        System.out.println("请输入数字A:");
        String num1 = sc.next();
        operation.setNumberA(Double.parseDouble(num1));
        System.out.println("请输入数字B:");
        String num2 = sc.next();
        operation.setNumberB(Double.parseDouble(num2));
        double result = operation.getResult();
        System.out.println("运算得到的结果为：" + result);
    }
}

        这种模式的好处显而易见，创建对象简单明了，易扩展任意的其他算法类。当然缺点也有，比如没创建一个类都需要在工厂类中加一个switch分支。