工厂模式

工厂模式的意义是将实例化对象的过程提取出来，放到一个类中进行统一管理和维护，从而实现与主业务的解耦，提高扩展性和维护性。

目前存在三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）

基于一个场景，进行介绍。

场景需求要点如下：

• 披萨有许多品种。

• 披萨的制作流程中，不同的种类有不一样的地方。例如准备、烘烤、切块、打包等。

• 实现披萨订购功能

传统的方法：

（1）首先创建一个披萨的父类，不同种类的披萨继承与这个披萨父类

（2）订购披萨类，订购时进行披萨类型判断，按照类型创建相应的披萨类，然后进行准备、烘烤、切块、打包等处理。

简单工厂模式：

则是将披萨类的创建过程，抽象封装成工厂类，专门处理披萨类的创建。

工厂模式：

当需求进一步添加，新增加不同的区域进行扩充披萨的种类。

则是在订购类中创建抽象方法，有不同区域的工厂类去实现。

抽象工厂模式：

将工厂模式的订购类中抽象方法，抽取出来定义为接口（抽象工厂），其它工厂类（具体工厂）去实现接口。

传统方法

实例化披萨类过程与订购业务耦合在一起，但出现的新的披萨类，则需要修改订购业务代码。

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();

        } 

简单工厂模式

将披萨类的实例化过程抽取封装成统一的工厂类

public class OrderPizza {

	Pizza pizza = null;
	String orderType = "";
	// 构造器
	public OrderPizza() {
		
		do {
			orderType = getType();
			pizza = SimpleFactory.createPizza2(orderType);
			// 输出pizza
			if (pizza != null) { // 订购成功
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				System.out.println(" 订购披萨失败 ");
				break;
			}
		} while (true);
	}
}
//简单工厂类
public class SimpleFactory {
	
	//简单工厂模式 也叫 静态工厂模式 
	
	public static Pizza createPizza2(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;
	}

}

工厂方法模式

将订购类和工厂类的依赖倒转，更有利于工厂类扩展

public abstract class OrderPizza {

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

}
// 实现抽象方法
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();
		}
		// TODO Auto-generated method stub
		return pizza;
	}
}
public class LDOrderPizza extends OrderPizza {
	@Override
	Pizza createPizza(String orderType) {
	
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new LDPepperPizza();
		}
		// TODO Auto-generated method stub
		return pizza;
	}

}

抽象工厂模式

将工厂模式的订购类中抽象方法，抽取出来定义为接口（抽象工厂），其它工厂类（具体工厂）去实现接口。

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);
	}
}
//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
	//让下面的工厂子类来 具体实现
	public Pizza createPizza(String orderType);
}
//这是工厂子类
public class BJFactory implements AbsFactory {

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~");
		// TODO Auto-generated method stub
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new BJCheesePizza();
		} else if (orderType.equals("pepper")){
			pizza = new BJPepperPizza();
		}
		return pizza;
	}

}
public class LDFactory implements AbsFactory {

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~");
		Pizza pizza = null;
		if (orderType.equals("cheese")) {
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new LDPepperPizza();
		}
		return pizza;
	}

}