Java设计模式——工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
下面通过 一个披萨店订购的需求 来认识三种工厂模式。

简单工厂模式

具体需求：
要便于披萨种类的扩展，要便于维护
1)披萨的种类很多(比如GreekPizza、CheesePizza 等)
2)披萨的制作有：准备prepare，烘烤bake, 切块cut, 包装box
3)完成披萨店订购功能。
传统方式
思路分析

编写OrderPizza.java去订购需要的各种Pizza

public class OrderPizza {

	// 构造器
	public OrderPizza() {
		Pizza pizza = null;
		String orderType; // 订购披萨的类型
		do {
			orderType = getType();//获得披萨的种类
			if (orderType.equals("greek")) {
				pizza = new GreekPizza();
				pizza.setName(" 希腊披萨 ");
			} else if (orderType.equals("cheese")) {
				pizza = new CheesePizza();
				pizza.setName(" 奶酪披萨 ");
			} else if (orderType.equals("pepper")) {
				pizza = new PepperPizza();
				pizza.setName("胡椒披萨");
			} else {
				break;
			}
			//输出pizza 制作过程
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();			
		} while (true);
	}

这种传统方式的优缺点：
1）较好理解，操作简单
2）但是违反了开闭原则，即对扩展开放，对修改关闭。当我们给类增加新的功能的时候，尽量少修改代码甚至不修改代码。直接体现就是，在这里如果要增加一个Pizza种类，那么就要新增加一个Pizza类，而且订购Pizza的类OrderPizza也要修改。
4）改进思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改改类就可，其他有创建Pizza对象的代码就不需要修改了->简单工厂模式。
简单工厂模式
基本介绍 ：
1）简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例
2）定义了一个创建对象的类，由这个类来封装实例化对象的行为

定义一个可以实例化Pizza对象的类，封装创建对象的代码
SimpleFactory.java

//简单工厂类
public class SimpleFactory{
	public static Pizza createPizza(String orderType){
		Pizza pizza=null;
		System.out.println("使用简单工厂模式2");
		if(orderType.equals("greek")){
			pizza=new GreekPizza();
			pizza.setName("希腊披萨");
		}else if(orderType.equals("cheese")){
			pizza=new CheesePizza();
			pizza.setName("奶酪披萨");
		}else if(orderType.equals("pepper")){
			pizza=new PepperPizza();
			pizza.setName("胡椒披萨");
		}
		return pizza;
		}
	}

订购类OrderPizza.java

public class OrderPizza{
	//定义一个简单工厂对象
	SimpleFactory simpleFactory;
	Pizza pizza=null;
	//构造器
	public OrderPizza(SimpleFactory simpleFactory){
		setFactory(simpleFactory);
	}
	public void setFactory(SimpleFactory simpleFactory){
		String orderType="";//用户输入的
		this.simpleFactory=simpleFactory;//设置简单工厂对象		
		do{
			orderType=getType();//获取披萨类型
			pizza=this.simpleFactory.createPizza(orderType)
			//输出pizza
			if(pizza!=null){//订购成功
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			}else{
				System.out.println("订购披萨失败");
				break;
			}
		}while(true);
	}
}

工厂方法模式

在上面例子的基础上，增加一个新的需求，不同地域不同口味的披萨，如北京的奶酪披萨，北京的胡椒披萨，伦敦的奶酪披萨，伦敦的胡椒披萨。
对于新需求，如果采用简单工厂模式，那么就需要创建不同的简单工厂类，但是考虑到项目的规模，以及软件的可维护性、可拓展性不是很好。
这种情况可以采用工厂方法模式：
工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的对象。工厂方法模式将对象的实例化推迟到子类。
具体实现：
1）思路分析：

2）代码
订购类OrderPizza.java

public abstract class OrderPizza{
	//定义一个抽象方法，createPizza,让各个工厂子类自己实现
	abstract Pizza createPizza(String orderType);
	//构造器
	public OrderPizza(){
		Pizza pizza=null;
		String orderType;//订购披萨的类型
		do{
			orderType=getType();//获取Pizza的类型
			pizza=createPizza(orderType);//抽象方法，由工厂子类完成
			//输出pizza制作过程
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
		}while(true);
	}
}

北京订购类BJOrderPizza.java（其他的订购类都差不多一样）

public class BJOrderPizza extends OrderPizza{
	@Override
	Pizza createPizza(String orderType){
		Pizza pizza=null;
		if(orderType.equals("cheese")){
			pizza=new BJCheesePizza();
		}else if(orderType.equals("pepper")){
			pizza=new BJPepperPizza();
		}
		return pizza;
	}
}

抽象工厂模式

基本介绍
1）抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需知名具体的类
2）抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
3）从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者成为进一步抽象）
4）将工厂抽象成两层，抽象工厂和具体实现的工厂子类。程序员可以根据对象创建类型使用对应的工厂子类。这样将单个的简单工厂类编程工厂簇，更利于代码的维护和扩展。

抽象层AbsFactory.java

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory{
	//让下面的工厂子类来具体实现
	public Pizza createPizza(String orderType);
}

工厂子类：北京工厂类（其他工厂类类似）BJFactory.java

//这是工厂子类
public class BJFactory implements AbsFactory{
	@Override
	public Pizza createPizza(String orderType){
		System.out.println("~使用的是抽象工厂模式~");
		Pizza pizza=null;
		if(orderType.equals("cheese")){
			pizza=new BJCheesePizza();
		}else if(orderType.equals("pepper")){
			pizza=new BJPepperPizza();
		}
		return pizza;
	}
}

订购类OrderPizza.java

public class OrderPizza{
	AbsFactory factory;
	//构造器
	public OrderPizza(AbsFactory factory){
		setFactory(factory);
	}
	private void setFactory(AbsFactory factory){
		Pizza pizza=null;
		String orderType="";//用户输入
		this.factory=factory;
		do{
			orderType=getType();
			//factory可能是北京的工厂子类，也可能是伦敦的工厂子类
			pizza=factory.createPizza(orderType);
			if(pizza!=null){//订购ok
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
		}else{
			System.out.println("订购失败");
			break;
		}
	}while(true);
}

工厂模式小结

1）工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展性和维护性。
2）设计模式的依赖抽象原则
①常见对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。或者说，变量不要直接持有具体类的应用
②不要让类继承具体类，而是继承抽象类或者实现接口
③不要覆盖基类中已经实现的方法。