第五章 工厂模式在开发中的作用

一、面试题

1.1 需求

1、 写出一个简单的计算器

public class TestMain {

    public static void main(String[] args) {
        System.out.println("======   简单计算程序   =======");
        System.out.println("输入第一个参数：");
        Scanner scanner = new Scanner(System.in);
        String first = scanner.nextLine();
        System.out.println("请输入运算符：");
        String per = scanner.nextLine();
        System.out.println("请输入第二个参数");
        String second = scanner.next();
        Double result = 0.0;
        switch (per){
            case "+":
                result = Double.parseDouble(first) + Double.parseDouble(second);
                break;
            case "-":
                result = Double.parseDouble(first) - Double.parseDouble(second);
                break;
            case "*":
                result = Double.parseDouble(first) * Double.parseDouble(second);
                break;
            case "/":
                result = Double.parseDouble(first) / Double.parseDouble(second);
                break;
            default:
                break;
        }
        System.out.println(result);
    }

}

• 运行结果：
  

1.2、使用工厂方法模式优化

1、抽象角色：运算类

public class Operation {

    private double first;

    private double second;

    public double getFirst() {
        return first;
    }

    public void setFirst(double first) {
        this.first = first;
    }

    public double getSecond() {
        return second;
    }

    public void setSecond(double second) {
        this.second = second;
    }

    public double run(){
        return  0.0;
    };

}

2、产品角色：相加类；继承自抽象角色

public class AddOperation extends Operation{

    @Override
    public double run() {
        return this.getFirst() + this.getSecond();
    }
}

3、产品角色：除法；继承自抽象角色

public class DivisionOperation extends Operation {

    @Override
    public double run() {
        return this.getFirst() / this.getSecond();
    }
}

4、产品角色：乘法；继承自抽象角色

public class MultiplicationOperation extends Operation{

    @Override
    public double run() {
        return this.getFirst() * this.getSecond();
    }
}

5、产品角色：减法；继承自抽象角色

public class SubOperation extends Operation{

    @Override
    public double run() {
        return this.getFirst() - this.getSecond();
    }
}

6、抽象工厂角色：运算类工厂接口

public interface OperationFactory {

    Operation getOperation();

}

7、具体工厂角色：加法生产工厂；继承自抽象工厂

public class AddOperationFactory implements OperationFactory {

    @Override
    public Operation getOperation() {
        return new AddOperation();
    }
}

8、具体工厂角色：除法生产工厂；继承自抽象工厂

public class DivisionOperationFactory implements OperationFactory {

    @Override
    public Operation getOperation() {
        return new DivisionOperation();
    }
}

9、具体工厂角色：乘法生产工厂；继承自抽象工厂

public class MultiplicationOperationFactory implements  OperationFactory {

    @Override
    public Operation getOperation() {
        return new MultiplicationOperation();
    }
}

10、具体工厂角色：减法生产工厂；继承自抽象工厂

public class SubOperationFactory implements  OperationFactory{

    @Override
    public Operation getOperation() {
        return new SubOperation();
    }
}

11、新启动类

public class TestMain {

    public static void main(String[] args) {
        System.out.println("======   简单计算程序   =======");
        System.out.println("输入第一个参数：");
        Scanner scanner = new Scanner(System.in);
        String first = scanner.nextLine();
        System.out.println("请输入第二个参数");
        String second = scanner.next();
        double result = 0.0;
        double one = Double.parseDouble(first);
        double two = Double.parseDouble(second);
        OperationFactory addOperationFactory = new AddOperationFactory();
        Operation addOperation = addOperationFactory.getOperation();
        addOperation.setFirst(one);
        addOperation.setSecond(two);
        System.out.println("加法运算结果 = " + addOperation.run());
        System.out.println("=====================================");
        OperationFactory subOperationFactory = new SubOperationFactory();
        Operation subOperation = subOperationFactory.getOperation();
        subOperation.setFirst(one);
        subOperation.setSecond(two);
        System.out.println("减法运算结果 = " + subOperation.run());
        System.out.println("======================================");
        OperationFactory multiplicationOperationFactory = new MultiplicationOperationFactory();
        Operation multiplicationOperation = multiplicationOperationFactory.getOperation();
        multiplicationOperation.setFirst(one);
        multiplicationOperation.setSecond(two);
        System.out.println("乘法运算结果 = " + multiplicationOperation.run());
        OperationFactory divisionOperationFactory = new DivisionOperationFactory();
        Operation divisionOperation = divisionOperationFactory.getOperation();
        divisionOperation.setFirst(one);
        divisionOperation.setSecond(two);
        System.out.println("除法运算结果 = " + divisionOperation.run());
    }

}

12、测试结果