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

2015年7月，去了tx实习，不说学习了很多，倒是看到了很多，实习回来决定好好学一下设计模式，看了一本很不错的书《大话设计模式》，我一直在研究，真心推荐，现在写一写自己的总结，认真对待。

我们初学者，虽然听了很多面向对象的东西，也写了很多面向对象的代码，却发现自己很难有面向对象的思想，一上来还都是面向过程的东西，就比如《大话设计模式》中的第一章所说的“代码无错就是优？”，我学到现在才发现真的不是，真正的好代码是容易扩展的、维护的，要做到这两点，设计出来的程序就应该是低耦合，高内聚，灵活，遵循一定的设计模式、原则，编程是一门艺术，更是一种享受，自己缺乏的太多了！好了，不bb了，写总结。

就如《大话》里的第一章，写一个最简单的计算机的控制台程序，我脑子一上来就是在main函数里定义两个数、输入、计算、输出，这就是很典型的面向过程，如果把程序移植到web端，又会发生会什么！！！ 一点都复用不上，重写！

一开始的代码：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double numA, numB, result = 0;
        char op;
        numA = scanner.nextDouble();
        numB = scanner.nextDouble();
        op = scanner.next().charAt(0);
        switch (op) {
            case '+':
                result = numA + numB;
                break;
            case '-':
                result = numA - numB;
                break;
            case '*':
                result = numA * numB;
                break;
            case '/':
                result = numA / numB;// 注意numB为零的情况
        }
        System.out.println(result);
        scanner.close();
    }

先分析不好在那里：

1.把计算逻辑和展示界面混合在一起了，耦合高

2.把计算逻辑中的加减乘除混合在一乐，耦合高

如何改进？

1.分离计算逻辑和界面

2.抽象出来一个计算类的父类，每个计算类继承与它

3.用简单工厂模式来生产计算对象

4.用反射来替换判断语句

上码：

计算类的父类：

public abstract class Operator {
    protected double numA;
    protected double numB;

    protected abstract double operate();

    protected void setNumA(double numA) {
        this.numA = numA;
    }

    protected void setNumB(double numB) {
        this.numB = numB;
    }
}

计算类的子类：

public class AddOperator extends Operator {
    @Override
    protected double operate() {
        return numA + numB;
    }
}

public class DivOperator extends Operator {
    @Override
    protected double operate() {
        if (Double.compare(numB, 0) == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        return numA / numB;
    }
}

public class MultiOperator extends Operator {
    @Override
    protected double operate() {
        return numA * numB;
    }
}

public class SubOperator extends Operator {
    @Override
    protected double operate() {
        return numA - numB;
    }
}

简单工厂类：

public class OperatorFactory {
    private static OperatorFactory instance;

    private OperatorFactory() {
    }

    public static OperatorFactory getInstance() {
        if (instance == null) {
            instance = new OperatorFactory();
        }
        return instance;
    }
    // 去实例化对象的问题
    public Operator createOperator(String op) {
        Operator operator = null;

        try {
            operator = (Operator) Class.forName(
                    getClass().getPackage().getName() + "." + op + "Operator").newInstance();
        } catch (Exception e) {
        }
        return operator;
    }
}

现在就做到：

1.逻辑与界面分离，逻辑都是通用的，可移植——封装，运算逻辑可以复用

2.容易扩展，比如加一个开方的运算，只需要加一个开方类，并不涉及到别的类——松耦合，各个运算互不影响

还有一点，文字表述太不直观了，最好用UML，一定补上！

(astah画的，免费简单)

perfect，建议大家一定要读《大话设计模式》