大话设计模式：简单工厂模式

1.开闭原则：用抽象构建架构，用实现扩展细节

2.依赖倒置原则：高层模块不应该依赖于底层模块，二者都应该依赖其抽象

3.单一职责原则：单个接口或类不应该有多个职责，应该尽可能的划分职责，通过组合的方式，完成更为复杂的业务

4.接口隔离原则：一个接口不要包含过多的职责，应合理划分，跟单一职责原则相辅相成

5.迪米特法则：也就最少知道原则，一个对象尽量让其它对象保持最少的了解

6.里氏替换原则：在引用父类的地方，都可以替换为其子类。从而可以实现子类间的动态切换。换句话说就是要有面向接口的编程思维。结合“开闭原则”，完美

7.合成复用原则：多用组合，少用继承

抽象的运算符类

@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class Operator {
    protected double numberA;
    protected double numberB;

    public abstract double getResult();

}

具体的运算符类

//加法运算类
public class Addition extends Operator {
    @Override
    public double getResult() {
        return numberA + numberB;
    }
}
//除法运算类
public class Division extends Operator {
    @Override
    public double getResult() {
        return numberA / numberB;
    }
}
//乘法运算类
public class Multiplication extends Operator{
    @Override
    public double getResult() {
        return numberA * numberB;
    }
}
//减法运算类
public class Subtraction extends Operator{
    @Override
    public double getResult() {
        return numberA - numberB;
    }
}

工厂类

public class OperatorFactory {
    public static Operator getOperator(String operatorChar){
        Operator operator = null;
        switch (operatorChar.charAt(0)) {
            case '+':
                operator = new Addition();
                break;
            case '-':
                operator = new Subtraction();
                break;
            case '*':
                operator = new Multiplication();
                break;
            case '/':
                operator = new Division();
                break;
        }
        return operator;
    }
}

主类

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个操作数");
        double numberA = scanner.nextDouble();
        scanner.nextLine();
        System.out.println("请输入运算符");
        String operatorChar = scanner.nextLine();
        System.out.println("请输入第二个操作数");
        double numberB = scanner.nextDouble();
        Operator operator = OperatorFactory.getOperator(operatorChar);
        operator.setNumberA(numberA);
        operator.setNumberB(numberB);
        System.out.println(operator.getResult());
    }
}

这个工厂类还可以使用反射进行优化
反射优化后的工厂类

public class OperatorFactory {
    private static Map<String, String> book;

    static {
        book=new HashMap<>();
        book.put("+", "com.DesignPatterns.simpleFactory.proxy.Addition");
        book.put("-", "com.DesignPatterns.simpleFactory.proxy.Subtraction");
        book.put("*", "com.DesignPatterns.simpleFactory.proxy.Multiplication");
        book.put("/", "com.DesignPatterns.simpleFactory.proxy.Division");
    }

    public static Operator getOperator(String operatorChar) {
        Operator operator = null;
        try {
            Class<?> operatorClass = Class.forName(book.get(operatorChar));
            operator = (Operator) operatorClass.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return operator;
    }
}