活字印刷 面向对象

书中描述了一个刻板印刷曹操《短歌行》的小故事，在活字印刷发明之前，都是整版印刷。有一个字需要调整，整个刻板都要作废，而且一个刻板只能使用一次，下次印刷新内容又要重新来过。有了活字印刷以后，每个字做一个小的刻板，每次调整内容只要换成对应字的刻板就可以，其余内容可以继续使用，而且可以重复使用。

1.要改，只需要改要改之字，此为 可维护
2.每个字可以在后来的印刷中重复使用，此乃 可复用
3.内容如要加字，只需另刻字加入即可，这是 可扩展
4.字的排列可以是横排也可是竖排，只需移动活字就可满足排列需求，此是 灵活性好

面向对象的好处

通过封装、继承、多态把程序的耦合度降低。传统印刷术的问题就在于所有的字都在一个刻板上，耦合度太高。使用设计模式可以使程序更加的灵活，容易修改，并且易于复用。

简单工厂模式

计算器的实例

要实现一个简单的计算器功能，简单的做法如下：

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        try {
            float firstNum = in.nextFloat();
            System.out.println("请输入第二个数字：");
            float secondNum = in.nextFloat();
            System.out.println("请输入运算符号：(+、-、*、/)");
            String operate = in.next();
            switch (operate) {
                case "+":
                    System.out.println("result : " + (firstNum + secondNum));
                    break;
                case "-":
                    System.out.println("result : " + (firstNum - secondNum));
                    break;
                case "*":
                    System.out.println("result : " + (firstNum * secondNum));
                    break;
                case "/":
                    if (secondNum != 0) {
                        System.out.println("result : " + (firstNum / secondNum));
                    } else {
                        System.out.println("除数不能为0");
                    }
                    break;
            }

        } catch (InputMismatchException e) {
            System.out.println("请输入数字");
        }
    }
}

上面的代码虽然可以满足功能，但是不易扩展。可维护性差。
如果需要新增一个新的操作（如：开方），加减乘除的运算都需要参与编译，一不小心误改了其他操作的代码，会造成额外的负担。这就引导我们把加减乘除的操作分开，每次修改代码，只修改需要改的地方，不用担心影响其他操作。很容易想到把运算抽象为一个父类，有一个获取结果的方法，加减乘除分别继承运算类，实现相应的获取结果方法。这样一来，问题是如何实例化运算对象，这就需要引入简单工厂模式。到底实例化那个对象，以及后面会不会增加新的实例，应该考虑用一个单独的类来做创建实例的过程，这就是工厂。

UML类图

希望慢慢学着画UML图

图片.png

JAVA代码

操作类

public class Operation {

    private double numberA;

    private double numberB;

    public double getResult() throws Exception {
        double result = 0;
        return result;
    }

    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 class OperationAdd extends Operation {

    @Override
    public double getResult() {
        double result = getNumberA() + getNumberB();
        return result;
    }

}

其他操作类似，为了节约篇幅，就省略了~~~

运算工厂类

public class OperationFactory {

    public static Operation createOperation(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
        }
        return operation;
    }

}

调用代码

    public static void main(String[] args) throws Exception {
        Operation operation = OperationFactory.createOperation("+");
        operation.setNumberA(10);
        operation.setNumberB(10);
        print(operation.getResult());
    }

这样一来，增加新的运算，只要新增一个运算类的子类就可以，不需要修改其他子类的代码，在工厂类里添加实例化的代码就可以通过操作符实例化出需要的对象。

总结

简单工厂模式应该是最简单的一种设计模式，与其说是设计模式，不如说是一种编码习惯，用面向对象思想编程的习惯。