（1）设计模式之简单工厂模式

简单工厂模式

写一个计算器程序，要求输入两个数和运算符号，得到结果。

如果看到要求直接写代码，可能会把所有代码都写到一个类里面，对于初学编程的小白来说，只要实现功能就可以，不会去想完成要求的功能之后，这段代码将来会怎么用，怎么维护，怎么增加删除和修改代码。

而如果以后做软件开发，实际的以后用到的代码都要有可维护，可复用，可扩展，灵活性好的特征，这也就需要学习设计模式。

如果需要新增一个取余运算，只写一个类的代码，显然需要在繁琐的代码里面找到需要修改的地方，然后再进行修改，这样的代码的可维护性、可复用性、可扩展性都极差，那么如何解决这一问题呢？

要学会面向对象变成，而面向对象变成的主要三个特征是 封装、继承、多态，所以我们要考虑通过封装、继承、多态把程序的耦合度降低，使用设计模式使得程序更加的灵活，容易修改，并且易于复用。

那么什么是简单工厂模式？
学习设计模式，还是要先从UML图着手，这里以加减乘除（计算器）运算为例给出UML图

简单工厂模式把每一个运算都写成了一个类，并且继承了运算类的接口，并对运算类的方法进行实现（根据运算类的不同，实现的方法也不同）。

运算类的父类接口包含了两个对象，分别作为运算的两个数，还有一个获取结果的方法（其子类实现该接口的时候需要实现此方法），接口是用来封装隔离具体实现的。

简单工厂类里面包含了运算类父类的对象，在简单工厂类里面根据运算符的不同，用运算类的父类实例化不同的运算类并返回。

最后只需要在客户端创建一个运算类的父类接口，运用简单工厂类的方法给该接口实例化出一个具体的运算类，然后给该接口对象（已经被子类实例化过的）设置运算的两个值，然后运用方法返回结果，输出。

简单工厂模式的本质是选择实现

代码实现（JAVA）：

package caculator;
//运算器父类
public abstract class Operation {
	private double _numberA=0;
	private double _numberB=0;
	public double get_numberA() {
		return _numberA;
	}
	public void set_numberA(double _numberA) {
		this._numberA = _numberA;
	}
	public double get_numberB() {
		return _numberB;
	}
	public void set_numberB(double _numberB) {
		this._numberB = _numberB;
	}
	
	public double GetResult(){
		double result=0;
		return result;
	}

}
package caculator;
//运算器加法类
public class OperationAdd extends Operation {
	@Override
	public double GetResult(){
		double result=0;
		result = get_numberA()+get_numberB();
		return result;
		
	}
}
package caculator;
//运算器除法类
public class OperationDiv extends Operation {
	@Override
	public double GetResult(){
		double result=0;
		if(get_numberB()==0){
			try {
				throw new Exception("除数不能为0！");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		result = get_numberA()/get_numberB();
		return result;
	}
}
package caculator;
//运算器乘法类
public class OperationMul extends Operation {
	@Override
	public double GetResult(){
		double result=0;
		result = get_numberA()*get_numberB();
		return result;
		
	}
}
package caculator;
//运算器减法类
public class OperationSub extends Operation {
	@Override
	public double GetResult(){
		double result=0;
		result = get_numberA()-get_numberB();
		return result;
		
	}
}
package caculator;
//简单工厂类
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 OperationDiv();
			break;
		case "*":
			oper=new OperationMul();
			break;
		default:
			break;
		}
		return oper;
		
	}
}
package caculator;
//客户端类
public class CaculatorTest {

	public static void main(String[] args) {
		Operation oper;
		oper=OperationFactory.createOperation("+");//根据运算符不同，实例化出不同的运算类
		oper.set_numberA(1.5);
		oper.set_numberB(2);
		double result = oper.GetResult();//调用实例化出的对象的方法（多态）
		System.out.println(result);

	}

}

简单工厂模式的缺点：
每次增加新的功能的时候，需要对简单工厂类进行修改，有可能造成简单共产类不简单（复杂），而且违背了开放封闭原则。

第一次写设计模式的博客，有很多不足，会继续努力，争取让大家看的更明白！（其实就是自己用来复习设计模式的 ）