工厂模式

1.简单工厂

简单工厂其实不是一个设计模式，反而比较像一阵编程习惯，但是却被经常使用。

public interface Pizza {
	void prepare();
	void bake();
	void cut();
	void box();
	
}

public class CheesePizza implements Pizza{

	public void prepare() {
		// TODO Auto-generated method stub
		
	}

	public void bake() {
		// TODO Auto-generated method stub
		
	}

	public void cut() {
		// TODO Auto-generated method stub
		
	}

	public void box() {
		// TODO Auto-generated method stub
		
	}

}

public class ClamPizza implements Pizza{

	public void prepare() {
		// TODO Auto-generated method stub
		
	}

	public void bake() {
		// TODO Auto-generated method stub
		
	}

	public void cut() {
		// TODO Auto-generated method stub
		
	}

	public void box() {
		// TODO Auto-generated method stub
		
	}

}

public class PizzaStore {
	
	SimplePizzaFactory factory;
	
	public PizzaStore(SimplePizzaFactory factory) {
		this.factory = factory;
	}
	
	public Pizza orderPizza(String type) {
         //创建pizza的方法 又工厂控制 如果以后添加新的pizza 这个段代码不需要修改 只需要
        //修改 工厂类即可 因为可能多处用到工厂来 所以只需要修改工厂一处即可
		Pizza pizza = factory.createPizza(type);
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}
	
}

public class SimplePizzaFactory {
	
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if(type.equals("cheese")) {
			pizza = new CheesePizza();
		}else if(type.equals("clam")) {
			pizza = new ClamPizza();
		}
		return pizza;
	}

}

2 工厂方法模式 ：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到子类。简单工厂方法没有使用接口 直接用的是实现类，这里使用接口。

public abstract class Pizza {
	String name;
	String dough;
	String sauce;
	
	List<String> toppings = new ArrayList<>();
	
	void prepare() {
		System.out.println("Preparing "+name);
		System.out.println("Tossing dough...");
		System.out.println("Adding sauce..");
		System.out.println("Adding toppings:");
		for(int i=0;i<toppings.size();i++) {
			System.out.println("  "+toppings.get(i));
		}
	}
		
	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}
	
	void cut() {
		System.out.println("Cutting the pizza into pizza ");
	
	}
	
	void box() {
		System.out.println("Place pizza in offical PizzaStore box");
	}
	
	
	public String getName() {
		return name;
	}
		
}

public abstract class PizzaStore {
	
	
	public PizzaStore() {
		
	}
	
	public Pizza orderPizza(String type) {
        //定义方法 有具体类实现
		Pizza pizza = createPizza(type);
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}

	protected  abstract Pizza createPizza(String type) ;
	
}

public class NYPizzaStore extends PizzaStore{

	@Override
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if(type.equals("ny")) {
			pizza = new NyStyleCheesePizza();
		}else if(type.equals("chicago")) {
			pizza = new ChicagoStyleChessPizza();
		}
		return pizza;
	}

}

public class NyStyleCheesePizza extends Pizza{

	public NyStyleCheesePizza() {
		name = "NY Style Sauce and Cheese Pizza";
		dough = "Thin Crust Dough";
		sauce = "Marinara Sauce";
		toppings.add("Grated Reggiano Cheese");
	}
	
}

3 抽象工厂模式：提供一个接口，用于创建相关或依赖的对象的家族，而不需要明确指定具体类

这些是pizza原料的接口

public interface Cheese {

}
public interface Clams {

}

public interface Dough {

}
public interface Pepperoni {

}
public interface Sauce {

}
public interface Veggies {

}

原料工厂接口 

public interface PizzaIngredientFactory {
	Dough createDough();
	Sauce createSauce();
	Cheese createCheese();
	Veggies[] createVeggies();
	Pepperoni createPepperoni();
	Clams createClam();

}

原料工厂实现类

public class NyPizzaIngredientFactory implements PizzaIngredientFactory{

	@Override
	public Dough createDough() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Sauce createSauce() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Cheese createCheese() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Veggies[] createVeggies() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Pepperoni createPepperoni() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Clams createClam() {
		// TODO Auto-generated method stub
		return null;
	}

}

public abstract class Pizza {
	Dough dough;
	Sauce sauce;
	Cheese sheese;
	Veggies[] veggies;
	Pepperoni pepperoni;
	Clams clams;
	String name;
	
	
	//创建原料实现类
	public abstract void prepare() ;
		
	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}
	
	void cut() {
		System.out.println("Cutting the pizza into pizza ");
	
	}
	
	void box() {
		System.out.println("Place pizza in offical PizzaStore box");
	}
	
	
	public String getName() {
		return name;
	}
		
}

public class CheesePizza extends Pizza {

	PizzaIngredientFactory ingredientFactory;

	public CheesePizza(PizzaIngredientFactory ingredientFactory) {
		super();
		this.ingredientFactory = ingredientFactory;
	}

	
	//依靠工厂类 创建了一组原料实现类
	@Override
	public void prepare() {
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		sheese = ingredientFactory.createCheese();
		veggies = ingredientFactory.createVeggies();
		pepperoni = ingredientFactory.createPepperoni();
		clams = ingredientFactory.createClam();

	}

}

注意点：

抽象工厂的方法经常以工厂方法的方式实现。抽象工厂的任务是定义一个负责创建一组产品的接口，这个接口内的每个方法都负责创建一个具体产品，同时我们利用实现抽象工厂的子类来提供这些具体的做法，所以在抽象工厂中利用工厂方式实现生产方法是相当自然的做法。工厂方法模式通常一个接口 直接创建产品.。抽象工厂模式通常有多个接口，创建出多个组件，然后在组合出产品。