深入浅出设计模式-004：工厂模式(Factory Pattern)
一：工厂模式 定义了一个创建对象的接口，但由子类决定实例化的类是哪一个。工厂方法把类实例化推迟到子类。 将创建对象的代码集中在一个对象或方法中。可以避免代码的重复，并且更方便以后的维护。这也意味着客户在实例化对象时，只会依赖接口而不是具体类。 注意：对象的创建时现实的，如果不创建任何对象，就无法创建任何程序了。
二：abstract Product factoryMethod(String type) 工厂方法用来处理对象的创建，并将这样的行为封装在子类中。 工厂方法是抽象的，所以依赖子类来处理对象的创建 工厂方法必须返回一个产品，超类中定义的方法，通常使用到工厂方法的返回值 工厂方法将客户和实际创建具体产品的代码分隔开来。
三：依赖倒置原则：要依赖抽象，不要依赖具体类 不能让高层组件依赖底层组件。而且不管高层或底层组件，两者都应该依赖于抽象。 变量不可以持有具体类的引用：如果使用NEW,就会持有具体类的引用。可以使用工厂方法避开。 不要让类派生自具体类：如果派生自具体类，你就会依赖具体类。 不要覆盖基类中已实现的方法：如果覆盖基类已实现的方法，那么你的基类就不是一个真正适合被继承的抽象。基类已实现的方法应该由所有子类共享。
四：PizzaStore是高层组件，而Pizza的实现是底层组件。高层组件依赖这些具体比萨类。 public abstract class Pizza{ public String name; public String dough; public String sauce; public ArrayList toppings = new ArrayList();
public void prepare(){ Console.WriteLine("prepare"); } public void bake(){ Console.WriteLine("bake"); } public void cut(){ Console.WriteLine("cut"); } public void box(){ Console.WriteLine("box"); } public String getName(){ return name; } } public class NYStyleCheesePizza : Pizza{ public NYStyleCheesePizza(){ name = "NYStyleCheesePizza name"; dough = "NYStyleCheesePizza dough"; sauce = "NYStyleCheesePizza sauce"; toppings.Add("NYStyleCheesePizza"); } } public class ChicagoStyleCheesePizza : Pizza{ public ChicagoStyleCheesePizza(){ name = "ChicagoStyleCheesePizza name"; dough = "ChicagoStyleCheesePizza dough"; sauce = "ChicagoStyleCheesePizza sauce"; toppings.Add("ChicagoStyleCheesePizza"); } public void cut(){ Console.WriteLine("ChicagoStyleCheesePizza cut"); } }
public abstract class PizzaStore{ //创建者类，它定义了一个抽象的工厂方法，让子类实现此方法制造产品 public abstract Pizza createPizza(String type); public Pizza orderPizza(String type){ Pizza pizza; pizza = createPizza(type);
pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box();
return pizza; } } public class NYStyleCheesePizzaStore : PizzaStore{ public override Pizza createPizza(string type){ if (type.Equals("cheese")){ return new NYStyleCheesePizza(); } else{ return null; } } } public class ChicagoStyleCheesePizzaStore : PizzaStore{ public override Pizza createPizza(string type){ if (type.Equals("chicago")){ return new ChicagoStyleCheesePizza(); } else{ return null; } } } static void Main(string[] args) { PizzaStore cheeseStore = new NYStyleCheesePizzaStore(); PizzaStore chicageStore = new ChicagoStyleCheesePizzaStore();
Pizza pizza = cheeseStore.orderPizza("cheese"); Console.WriteLine(pizza.getName());
pizza = chicageStore.orderPizza("chicago"); Console.WriteLine(pizza.getName()); }
五：抽象工厂模式 提供一个接口，用于创建相关或依赖对象的家族，而不用明确执行具体类
//各种原料 public interface Dough{ string toString(); } public class ThickCrustDough : Dough{ public string toString(){ return "ThickCrust Dough"; } } public class ThinCrustDough : Dough{ public string toString(){ return "ThinCrust Dough"; } }
public interface Sauce{ string toString(); } public class MarinaraSauce : Sauce{ public string toString(){ return "Marinara Sauce"; } } public class PlumTomatoSauce : Sauce{ public string toString(){ return "PlumTomato Sauce"; } }
public interface Cheese{ string toString(); } public class Mozzerella : Cheese{ public string toString(){ return "Mozzerella Cheese"; } } public class ReggianoCheese : Cheese{ public string toString(){ return "ReggianoCheese Cheese"; } }
public interface Veggies{ string toString(); } public class RedPepper : Veggies{ public string toString(){ return "RedPepper Veggies"; } } public class Spinach : Veggies{ public string toString(){ return "Spinach Veggies"; } } public class BlackOlives : Veggies{ public string toString(){ return "BlackOlives Veggies"; } } public class EggPlant : Veggies{ public string toString(){ return "EggPlant Veggies"; } } public class Garlic : Veggies{ public string toString(){ return "Garlic Veggies"; } } public class Mushroom : Veggies{ public string toString(){ return "Mushroom Veggies"; } } public class Onion : Veggies{ public string toString(){ return "Onion Veggies"; } }
public interface Pepperoni{ string toString(); } public class SlicedPepperoni : Pepperoni{ public string toString(){ return "Sliced Pepperoni"; } }
public interface Clams{ string toString(); } public class FreshClams : Clams{ public string toString(){ return "FreshClams Clams"; } } public class FrozenClams : Clams{ public string toString(){ return "FrozenClams Clams"; } }
//原料供应商 public interface PizzaIngredientFactory{ Dough createDough(); Sauce createSauce(); Cheese createCheese(); Veggies[] createVeggies(); Pepperoni createPepperoni(); Clams createClams(); } public class NYPizzaIngredientFactory : PizzaIngredientFactory{ public Dough createDough(){ return new ThinCrustDough(); } public Sauce createSauce(){ return new MarinaraSauce(); } public Cheese createCheese(){ return new ReggianoCheese(); } public Veggies[] createVeggies(){ Veggies[] veggies = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() }; return veggies; } public Pepperoni createPepperoni(){ return new SlicedPepperoni(); } public Clams createClams(){ return new FreshClams(); } } public class ChicagoPizzaIngredientFactory : PizzaIngredientFactory{ public Dough createDough(){ return new ThickCrustDough(); } public Sauce createSauce(){ return new PlumTomatoSauce(); } public Cheese createCheese(){ return new Mozzerella(); } public Veggies[] createVeggies(){ Veggies[] veggies = { new BlackOlives(), new Spinach(), new EggPlant() }; return veggies; } public Pepperoni createPepperoni(){ return new SlicedPepperoni(); } public Clams createClams(){ return new FrozenClams(); } }
//产品，制作时，用到了哪个地方的哪些原材料 public abstract class Pizza{ public String name; public Dough dough; public Sauce sauce; public Veggies[] veggies; public Cheese cheese; public Pepperoni pepperoni; public Clams clam;
//各种PIZZA制作时选用的原材料不一样 public abstract void prepare(); public void bake(){ Console.WriteLine("bake"); } public void cut(){ Console.WriteLine("cut"); } public void box(){ Console.WriteLine("box"); } public String getName(){ return name; } } public class CheesePizza : Pizza{ PizzaIngredientFactory ingredientFactory; //选用了哪个地方的原材料 public CheesePizza(PizzaIngredientFactory ingredientFactory){ this.ingredientFactory = ingredientFactory; } public override void prepare(){ dough = ingredientFactory.createDough(); sauce = ingredientFactory.createSauce(); cheese = ingredientFactory.createCheese(); } } public class ClamPizza : Pizza{ PizzaIngredientFactory ingredientFactory; public ClamPizza(PizzaIngredientFactory ingredientFactory){ this.ingredientFactory = ingredientFactory; } public override void prepare(){ dough = ingredientFactory.createDough(); sauce = ingredientFactory.createSauce(); cheese = ingredientFactory.createCheese(); clam = ingredientFactory.createClams(); } }
public abstract class PizzaStore{ //创建者类，它定义了一个抽象的工厂方法，让子类实现此方法制造产品 public abstract Pizza createPizza(String type); public Pizza orderPizza(String type){ Pizza pizza; pizza = createPizza(type);
pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box();
return pizza; } } public class NYPizzaStore : PizzaStore{ public override Pizza createPizza(string type){ Pizza pizza = null; PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory(); if (type.Equals("cheese")){ pizza = new CheesePizza(ingredientFactory); } else if (type.Equals("clam")){ pizza = new ClamPizza(ingredientFactory); } return pizza; } } public class ChicagoPizzaStore : PizzaStore{ public override Pizza createPizza(string type){ Pizza pizza = null; PizzaIngredientFactory ingredientFactory = new ChicagoPizzaIngredientFactory(); if (type.Equals("cheese")){ pizza = new CheesePizza(ingredientFactory); } else if (type.Equals("clam")){ pizza = new ClamPizza(ingredientFactory); } return pizza; } }
static void Main(string[] args) { PizzaStore nyStore = new NYPizzaStore(); Pizza pizza = nyStore.orderPizza("cheese");
PizzaStore nyStore = new NYPizzaStore(); Pizza pizza = nyStore.OrderPizza("clam");
PizzaStore.PizzaStore nyStore = new NYPizzaStore(); Pizza pizza = nyStore.OrderPizza("pepperoni");
PizzaStore chicagoStore = new ChicagoPizzaStore(); Pizza pizza = chicagoStore.OrderPizza("cheese");
PizzaStore.PizzaStore chicagoStore = new ChicagoPizzaStore(); Pizza pizza = chicagoStore.OrderPizza("clam");
PizzaStore chicagoStore = new ChicagoPizzaStore(); Pizza pizza = chicagoStore.OrderPizza("pepperoni"); }
六：简单工厂和抽象工厂总结 所有的工厂都是用来封装对象的创建。 简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦。 工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象。 抽象工厂使用对象组合：对象的创建被实现在工厂接口锁暴露出来的方法中。 所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。 工厂方法允许类将实例化推迟到子类进行。 抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。 依赖倒置原则指导我们避免依赖具体类型，而要尽量依赖抽象。 工厂是很有威力的技巧，帮助我们针对抽象编程，而不要针对具体编程。
