初探设计模式——工厂模式

Pizza是超类型，CheesePizza、ClamPizza是其子类。

public abstract class Pizza{
	void prepare(){}
	void box(){}
}

得到一个具体对象：

Pizza cheesePizza=new CheesePizza();

得到多个具体对象:

Pizza pizza;	
if("cheese") 
	pizza=new CheesePizza();
else if("clam")
	pizza=new ClamPizza();
else if()...

如果要对Pizza类进行扩展就要在客户类中修改这段代码，违反了对修改封闭的原则
应用封装变化的原则，把这段具体实例化的过程抽离到一个类中，我们把这个类就叫工厂，用来处理创建对象的细节。

创建一个简单工厂,封装创建对象的代码，返回值为工厂产品

public class SimpleFactory{
	public Pizza createPizza(String type){	//通过这个方法实例化对象
		Pizza pizza =null;
		if(type.equals("cheese")){
			pizza=new CheesePizza();
		}else if(){}
		return pizza;
	}
}
		

这个工厂可以有很多客户，写一个PizzaStore客户不通过具体实例化来获得工厂产品

public class PizzaStore{
	SimplePizzaFactory factory;		//传入工厂类引用，用来获得pizza对象
	public PizzaStory(SimplePizzaFactory factory){
		this.factory=factory;			//将引用指向工厂对象
	}
	public Pizza orderPizza(String type){
		Pizza pizza;
		pizza=factory.creatPizza(type); 	//产生一个实例化对象并赋给pizza这个引用,这样客户中不需要出现具体实例化
		pizza.prepare();
		pizza.box();
		return pizza;
	}
}

这样通过PizzaStore就可以获得pizza对象，如果想要得到不同特色种的pizza只要多写几个简单工厂就行了

现在把PizzaStory作为超类，create方法变成抽象方法
这样通过继承这个超类，不同子类分别实现create方法也可以得到不同风味的pizza
把 orderPizza声明成final，prepare box等方法就被保证不被修改

public abstract class PizzaStore{
	public Pizza orderPizza(String type){
		Pizza pizza;

		pizza=createPizza(type);

		pizza.prepare();
		pizza.box();
		return pizza;
	}
	abstract Pizza createPizza(String type);
}

orderPizza实现了解耦，对修改封闭，对扩展开放。

工厂方法模式：定义一个创建对象的接口，但由继承来的子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

• 依赖倒置原则：要依赖抽象，不要依赖具体类。
• 变量不可以持有具体类的引用
• 不要让类派生自具体类
• 不要覆盖基类中已经实现的方法

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类
定义一个接口，子类实现pizza原料的方法，将子类实例化后组合到抽象类Pizza和PizzaStory的子类中。
。。。。菜啊