【设计模式】简单工厂模式

新手的通病

原先所写的程序，不容易维护，灵活性差，不容易扩展，更谈不上复用，因此面对需求变化，加班加点，对程序动大手术。

紧耦合的缺点：

在修改时存在不安全性（会进入类内部修改，这对于企业级应用是几乎不可能的，非常不安全），当增加一个功能时，需将整个类重新编译，修改时可能出错。且如果类内耦合过紧，不利于维护。

学过面向对象后

通过封装、继承、多态把程序的耦合度降低（传统印刷术的问题就在于所有的字都刻在同一版面上造成耦合度太高所制），开始用设计模式使得程序更加的灵活，容易修改，并且易于复用。
另外，要考虑避免重复,还要考虑业务逻辑和界面逻辑的分离。

有关工厂模式

工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。
工厂模式有以下几种形态：
简单工厂（Simple Factory）模式
工厂方法（Factory Method）模式
抽象工厂（Abstract Factory）模式

简单工厂模式

本质：选择实现

集中控制

Simple Factory模式根据提供给它的数据，返回几个可能类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法。

工厂类角色Creator (LightSimpleFactory)：工厂类在客户端的直接控制下（Create方法）创建产品对象。
抽象产品角色Product (Light)：定义简单工厂创建的对象的父类或它们共同拥有的接口。可以是一个类、抽象类或接口。
具体产品角色ConcreteProduct (BulbLight, TubeLight)：定义工厂具体加工出的对象。

接口是用来封装隔离具体的实现的，目标就是不要让客户端知道封装体内部的具体实现。
简单工厂的位置是位于封装体内的，所以简单工厂知道具体类的实现是没有关系的。
对于客户端来说，只是知道了接口和简单工厂，并不清楚具体的封装体内部的实现。

优缺点

优点：

工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅"消费"产品。简单工厂模式通过这种做法实现了对责任的分割。

缺点：

当产品有复杂的多层等级结构时，工厂类只有自己，以不变应万变，就是模式的缺点。因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
同时，系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂。
另外，简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。

应用场景

如果想要完全封装隔离具体实现，让外部只能通过接口来操作封装体，则可以选用简单工厂。让客户端通过工厂来获取相应的接口，而无需关心具体的实现。
如果想要把对外创建对象的职责集中管理和控制，可以选用简单工厂。

使用举例

实现计算器

package calculator;

public class Operation {

	private double numberA=0;
	private double numberB=0;
	
	
	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 double GetResult() throws Exception {
		return 0;
	}
}

package calculator;

public class OperationAdd extends Operation {

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

}

package calculator;

public class OperationDiv extends Operation{

	@Override
	public double GetResult() throws Exception {
		double result=0;
		if(getNumberB()==0) {
			throw new Exception("除数不为0！");
		}
		result=getNumberA()/getNumberB();
		return result;
	}

}

package calculator;

public class OperationFactory {

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

package calculator;

public class OperationMul extends Operation {

	@Override
	public double GetResult() {
		double result=0;
		result=getNumberA()*getNumberB();
		return result;
	}

}

package calculator;

public class OperationSub extends Operation {

	@Override
	public double GetResult() {
		double result=0;
		result=getNumberA()-getNumberB();
		return result;
	}

}

package calculator;

import java.util.Scanner;

public class Client {


	public static void main(String args[]) throws Exception {
		try {
			Operation oper;
			double inputA,inputB=0;
			String str;
			Scanner sc=new Scanner(System.in);
			System.out.println("输入数字A");
			inputA=sc.nextDouble();
			System.out.println("输入数字B");
			inputB=sc.nextDouble();
			System.out.println("输入运算符");
			str=sc.next();
			sc.close();
			oper=OperationFactory.creatOperate(str);
			oper.setNumberA(inputA);
			oper.setNumberB(inputB);
			double result=oper.GetResult();
			System.out.println(result);
		}catch (Exception e) {
			System.out.println("您的输入有误！"+e.getMessage());
		}
		
	}
}