大话设计模式——01简单工厂模式

一、由一道面试题引申出的问题

请用Java实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。需要体现出面向对象的编程思想。

很多新手开发觉得这道题没什么难度，只需要通过if判断分支，就可以实现这个需求。但这样写不但会存在冗余代码，也没有体现面向对象的编程思想。这样的程序既不容易维护，也不容易扩展，更不容易复用。

二、业务的封装

让业务逻辑和界面逻辑分开，降低它们的耦合度，这样才容易维护或扩展。

三、继承和多态

加入Operation运算类，通过AddOperation、SubOperation、MulOperation、DivOperation类继承Operation运算类，并重写getResul()方法。

public abstract class Operation {
	
	private Double param01;
	private Double param02;
	
	public Double getParam01() {
		return param01;
	}

	public void setParam01(Double param01) {
		this.param01 = param01;
	}

	public Double getParam02() {
		return param02;
	}

	public void setParam02(Double param02) {
		this.param02 = param02;
	}

	public abstract Double getResult(Double param01, Double param02) throws Exception;
	
}

public class AddOperation extends Operation {

	@Override
	public Double getResult(Double param01, Double param02) {
		return param01 + param02;
	}

}

public class SubOperation extends Operation {

	@Override
	public Double getResult(Double param01, Double param02) {
		return param01 - param02;
	}

}

public class MulOperation extends Operation {

	@Override
	public Double getResult(Double param01, Double param02) {
		return param01 * param02;
	}

}

public class DivOperation extends Operation {

	@Override
	public Double getResult(Double param01, Double param02) throws Exception {
		if (param02 == 0)
			throw new Exception("除数不能为0!");
		return param01 / param02;
	}

}

四、简单工厂模式 

解决如何实例化对象的问题，判断到底要实例化哪个对象。

public class OperationFactory {

	public static Operation createOperation(String symbol) {
		Operation oper = null;
		switch (symbol) {
			case "+":
				oper = new AddOperation();
				break;
			case "-":
				oper = new SubOperation();
				break;
			case "*":
				oper = new MulOperation();
				break;
			default:
				oper = new DivOperation();
				break;
		}
		return oper;
	}

}

 五、客户端代码

界面的实现就是这样的代码，不管你是控制台程序，Window程序，Web程序，都可以使用这段代码来实现计算器的功能，如果有一天我们需要更改加法运算，我们只需要改AddOperation类就可以了。如果我们需要增加其他算法，比如平方根，只需要增加Operation运算类相应的运算子类，并在OperationFactory工厂类switch中增加分支就可以了。

public class RunMain {

	public static void main(String[] args) throws Exception {
		
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入数字A：");
		String param01 = sc.next();
		
		System.out.println("请输入数字B：");
		String param02 = sc.next();
		
		System.out.println("请选择运算符号(+、-、*、/)：");
		String symbol = sc.next();
		
		Operation oper = OperationFactory.createOperation(symbol);
		Double result = oper.getResult(Double.valueOf(param01), Double.valueOf(param02));
		
		System.out.println("计算结果为：" + result);
		
	}

}

扩展：面向对象设计的3个基本特征和5个原则

• 三个基本特征：

1. 封装（重要特性: 数据隐藏），对象只对外提供与其它对象交互的必要接口,而将自身的某些属性和实现细节对外隐藏，保证了安全性。

2. 继承（重要特性: 复用性），可以通过实现继承、接口继承在不重复修改已实现的功能的前提下，对功能进行复用和扩展。

3. 多态，当存在继承关系时，允许将父类对象看成为和它的一个或多个子类对象等同，可以根据当前赋给父类对象的子对象的具体特性以不同的方式进行运行。

 　　　　多态的几个前提

　　　　　　a.要有继承关系。

　　　　　　b.要有方法重写。

　　　　　　c.要有父类引用指向子类对象。

        　　多态的好处

　　　　　　a.提高了代码的维护性(继承保证)。

　　　　　　b.提高了代码的扩展性(由多态保证)。

　　　　多态的限制

          　　    a.不能使用子类的特有属性和行为。

• 五大基本原则：

1. 单一职责原则SRP(Single Responsibility Principle)，是指一个类的功能要单一，不能包罗万象。

2. 开放封闭原则OCP(Open－Close Principle)，一个模块在扩展性方面应该是开放的，而在更改性方面应该是封闭的。

3. 里氏代换原则LSP(the Liskov Substitution Principle)，子类应当可以替换父类并出现在父类能够出现的任何地方。

4. 依赖倒转原则DIP(the Dependency Inversion Principle)，具体依赖抽象，上层依赖下层。　

   假设B是较A低的模块，但B需要使用到A的功能，这个时候，B不应当直接使用A中的具体类， 而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口，这样就达到了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。

5. 接口分离原则ISP(the Interface Segregation Principle)，模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来。