设计模式学习--工厂模式(Factory Pattern)

最新推荐文章于 2021-03-24 09:38:37 发布
最新推荐文章于 2021-03-24 09:38:37 发布
阅读量541 收藏
点赞数
分类专栏： 设计模式 文章标签： android 设计模式

什么是工厂模式？

工厂模式可分为以下三种类型，需要根据不同需求来决定使用哪一种模式:
1. 简单工厂（不是真正意义上的设计模式）
2. 工厂方法（定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类实例化推迟到子类）
3. 抽象工厂（提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类）


面向对象原则：

多用组合，少用继承
针对接口编程，不针对实现编程
为交互对象之间的松耦合而努力（将创建和使用分离成不同的类）
类应该对扩展开放，对修改关闭
依赖抽象，不是依赖具体类（新的原则）


要点：

1. 所有的工厂都是用来封装对象的创建。
2. 简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦。
3. 工厂方法使用继承：把对象的创建委托给子类子类实现工厂方法来创建对象。
4. 抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。
5. 所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。
6. 工厂方法允许类将实例化延迟到子类进行。
7. 抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。
8. 依赖倒置原则，指导我们避免依赖具体类型，而要尽量依赖抽象。
9. 工厂是很有威力的技巧，帮助我们针对抽象编程，而不要针对具体类编程。
10.用静态方法创建简单工程，是为了不需要创建对象，但是也有缺点，不能通过继承来改变创建方法的行为（当然也可以在抽象类中把方法定义为final或者static来防止子类对方法进行改变，双刃剑）。



工厂模式应用实例：比萨店

简单工厂实现

看看UML的类图


项目结构:



源代码：

/Pizza.java

[java]  view plain copy
  1. package pizzas;  
  2.   
  3. import java.util.ArrayList;  
  4. /*** 
  5.  *  抽象pizza类 
  6.  * 
  7.  */  
  8. abstract public class Pizza {  
  9.     String name;  
  10.     String dough;  
  11.     String sauce;  
  12.     ArrayList toppings = new ArrayList();  
  13.       
  14.       
  15.     public String getName() {  
  16.         return name;  
  17.     }  
  18.   
  19.   
  20.     @Override  
  21.     public String toString() {  
  22.         StringBuffer display = new StringBuffer();  
  23.         display.append("----" + name + "----\n");  
  24.         display.append(dough + "\n");  
  25.         display.append(sauce + "\n");  
  26.         for(int i = 0; i < toppings.size(); i++) {  
  27.             display.append((String)toppings.get(i) + "\n");  
  28.         }  
  29.           
  30.         return display.toString();  
  31.     }  
  32.   
  33.     //准备  
  34.     public void prepare() {  
  35.         System.out.println("Preparing " + name);  
  36.     }  
  37.   
  38.     //烘烤  
  39.     public void bake() {  
  40.         System.out.println("Baking " + name);  
  41.     }  
  42.   
  43.     //切片  
  44.     public void cut() {  
  45.         System.out.println("Cutting " + name);  
  46.     }  
  47.   
  48.     //装箱  
  49.     public void box() {  
  50.         System.out.println("Boxing " + name);  
  51.     }  
  52.       
  53.       
  54. }  
[java]  view plain copy
  1. package pizzas;  
  2. /** 
  3.  * 
  4.  */  
  5. public class CheesePizza extends Pizza {  
  6.     @SuppressWarnings("unchecked")  
  7.     public CheesePizza() {  
  8.         name = "Cheese Pizza";  
  9.         dough = "Regular Crust";  
  10.         sauce = "Marinara Pizza Sauce";  
  11.         toppings.add("Fresh Mozzarella");  
  12.         toppings.add("Parmesan");  
  13.     }  
  14. }  

[java]  view plain copy
  1. package pizzas;  
  2. /** 
  3.  * 
  4.  */  
  5. public class ClamPizza extends Pizza {  
  6.     @SuppressWarnings("unchecked")  
  7.     public ClamPizza() {  
  8.         name = "Clam Pizza";  
  9.         dough = "Thin crust";  
  10.         sauce = "White garlic sauce";  
  11.         toppings.add("Clams");  
  12.         toppings.add("Grated parmesan cheese");  
  13.     }  
  14. }  

[java]  view plain copy
  1. package pizzas;  
  2. /** 
  3.  * 
  4.  */  
  5. public class PepperoniPizza extends Pizza {  
  6.     @SuppressWarnings("unchecked")  
  7.     public PepperoniPizza() {  
  8.         name = "Pepperoni Pizza";  
  9.         dough = "Crust";  
  10.         sauce = "Marinara sauce";  
  11.         toppings.add("Sliced Pepperoni");  
  12.         toppings.add("Sliced Onion");  
  13.         toppings.add("Grated parmesan cheese");  
  14.     }  
  15. }  


[java]  view plain copy
  1. package pizzas;  
  2. /** 
  3.  * 素食pizza 
  4.  * 
  5.  */  
  6. public class VegglePizza extends Pizza {  
  7.     @SuppressWarnings("unchecked")  
  8.     public VegglePizza(){  
  9.         name = "Veggie Pizza";  
  10.         dough = "Crust";  
  11.         sauce = "Marinara sauce";  
  12.         toppings.add("Shredded mozzarella");  
  13.         toppings.add("Grated parmesan");  
  14.         toppings.add("Diced onion");  
  15.         toppings.add("Sliced mushrooms");  
  16.         toppings.add("Sliced red pepper");  
  17.         toppings.add("Sliced black olives");  
  18.     }  
  19. }  


/SimplePizzaFactory.java

[java]  view plain copy
  1. package pizzas;  
  2. /** 
  3.  * 简单工厂方法 
  4.  */  
  5. public class SimplePizzaFactory {  
  6.     public Pizza createPizza(String type) {  
  7.         Pizza pizza = null;  
  8.           
  9.         if(type.equals("cheese")) {  
  10.             pizza = new CheesePizza();  
  11.         } else if(type.equals("pepperoni")) {  
  12.             pizza = new PepperoniPizza();  
  13.         } else if(type.equals("clam")) {  
  14.             pizza = new ClamPizza();  
  15.         } else if(type.equals("veggie")) {  
  16.             pizza = new VegglePizza();  
  17.         }  
  18.         return pizza;  
  19.     }  
  20. }  

/PizzaStore

[java]  view plain copy
  1. package pizzas;  
  2.   
  3. public class PizzaStore {  
  4.     SimplePizzaFactory factory;  
  5.   
  6.     public PizzaStore(SimplePizzaFactory factory) {  
  7.         this.factory = factory;  
  8.     }  
  9.       
  10.     public Pizza orderPizza(String type) {  
  11.         Pizza pizza;  
  12.           
  13.         pizza = factory.createPizza(type);  
  14.           
  15.         pizza.prepare();    //准备  
  16.         pizza.bake();       //烘烤  
  17.         pizza.cut();        //切片  
  18.         pizza.box();        //装盒  
  19.         return pizza;  
  20.     }  
  21. }  


/PizzaTestDriver

[java]  view plain copy
  1. package pizzas;  
  2. /** 
  3.  * 简单工厂的测试类 
  4.  */  
  5. public class PizzaTestDriver {  
  6.     public static void main(String[] args) {  
  7.         SimplePizzaFactory factory = new SimplePizzaFactory();  
  8.         PizzaStore store = new PizzaStore(factory);  
  9.           
  10.           
  11.         Pizza pizza = store.orderPizza("cheese");  
  12.         System.out.println("We ordered a " + pizza.getName() + "\n");  
  13.           
  14.         pizza = store.orderPizza("veggie");  
  15.         System.out.println("We ordered a " + pizza.getName() + "\n");  
  16.     }  
  17. }  

工厂方法模式实现




项目结构：


/Pizza.java

把Pizza声明为抽象的，让所有具体比萨都必须派生自这个类。
[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. import java.util.ArrayList;  
  4.   
  5. /** 
  6.  * 
  7.  */  
  8. public abstract class Pizza {  
  9.     String name;    //名称  
  10.     String dough;   //面团类型  
  11.     String sauce;   //一套佐料  
  12.     ArrayList toppings = new ArrayList();  
  13.       
  14.     public void prepare() {  
  15.         System.out.println("Preparing " + name);  
  16.         System.out.println("Tossing dough...");  
  17.         System.out.println("Adding sauce...");  
  18.         System.out.println("Adding toppings: ");  
  19.         for(int i = 0; i < toppings.size(); i++) {  
  20.             System.out.println("   " + toppings.get(i));  
  21.         }  
  22.     }  
  23.   
  24.     public void bake() {  
  25.         System.out.println("Bake for 25 minutes at 350");  
  26.     }  
  27.   
  28.     public void cut() {  
  29.         System.out.println("Cutting the pizza into diagonal slices");  
  30.     }  
  31.   
  32.     public void box() {  
  33.         System.out.println("Place pizza in official PizzaStore box");  
  34.     }  
  35.   
  36.     public String getName() {  
  37.         return name;  
  38.     }  
  39. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. /** 
  4.  * 纽约披萨 
  5.  * 
  6.  */  
  7. public class NYStyleCheesePizza extends Pizza {  
  8.     public NYStyleCheesePizza() {  
  9.         name = "NY Style Sauce and Cheese Pizza";  
  10.         dough = "Thin Crust Dough";  
  11.         sauce = "Marinara Sauce";  
  12.           
  13.         toppings.add("Grated Reggiano Cheese");  
  14.     }  
  15.       
  16. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. public class NYStyleClamPizza extends Pizza {  
  4.     public NYStyleClamPizza() {  
  5.         name = "NY Style Clam Pizza";  
  6.         dough = "Thin Crust Dough";  
  7.         sauce = "Marinara Sauce";  
  8.    
  9.         toppings.add("Grated Reggiano Cheese");  
  10.         toppings.add("Fresh Clams from Long Island Sound");  
  11.     }  
  12. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. public class NYStylePepperoniPizza extends Pizza {  
  4.     public NYStylePepperoniPizza() {  
  5.         name = "NY Style Pepperoni Pizza";  
  6.         dough = "Thin Crust Dough";  
  7.         sauce = "Marinara Sauce";  
  8.    
  9.         toppings.add("Grated Reggiano Cheese");  
  10.         toppings.add("Sliced Pepperoni");  
  11.         toppings.add("Garlic");  
  12.         toppings.add("Onion");  
  13.         toppings.add("Mushrooms");  
  14.         toppings.add("Red Pepper");  
  15.     }  
  16. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. public class NYStyleVeggiePizza extends Pizza {  
  4.     public NYStyleVeggiePizza() {  
  5.         name = "NY Style Veggie Pizza";  
  6.         dough = "Thin Crust Dough";  
  7.         sauce = "Marinara Sauce";  
  8.    
  9.         toppings.add("Grated Reggiano Cheese");  
  10.         toppings.add("Garlic");  
  11.         toppings.add("Onion");  
  12.         toppings.add("Mushrooms");  
  13.         toppings.add("Red Pepper");  
  14.     }  
  15. }  


[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. /** 
  4.  * 芝加哥披萨 
  5.  * 
  6.  */  
  7. public class ChicagoStyleCheesePizza extends Pizza {  
  8.     public ChicagoStyleCheesePizza() {  
  9.         name = "Chicago Style Deep Dish Cheese Pizza";  
  10.         dough = "Extra Thick Crust Dough";  
  11.         sauce = "Plum Tomato Sauce";  
  12.           
  13.         toppings.add("Shredded Mozzarella Cheese");  
  14.     }  
  15.     public void cut() {  
  16.         System.out.println("Cutting the pizza into square slices");  
  17.     }  
  18. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. public class ChicagoStyleClamPizza extends Pizza {  
  4.     public ChicagoStyleClamPizza() {  
  5.         name = "Chicago Style Clam Pizza";  
  6.         dough = "Extra Thick Crust Dough";  
  7.         sauce = "Plum Tomato Sauce";  
  8.    
  9.         toppings.add("Shredded Mozzarella Cheese");  
  10.         toppings.add("Frozen Clams from Chesapeake Bay");  
  11.     }  
  12.    
  13.     public void cut() {  
  14.         System.out.println("Cutting the pizza into square slices");  
  15.     }  
  16. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3.   
  4. public class ChicagoStylePepperoniPizza extends Pizza {  
  5.     public ChicagoStylePepperoniPizza() {  
  6.         name = "Chicago Style Pepperoni Pizza";  
  7.         dough = "Extra Thick Crust Dough";  
  8.         sauce = "Plum Tomato Sauce";  
  9.    
  10.         toppings.add("Shredded Mozzarella Cheese");  
  11.         toppings.add("Black Olives");  
  12.         toppings.add("Spinach");  
  13.         toppings.add("Eggplant");  
  14.         toppings.add("Sliced Pepperoni");  
  15.     }  
  16.    
  17.     public void cut() {  
  18.         System.out.println("Cutting the pizza into square slices");  
  19.     }  
  20. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. public class ChicagoStyleVeggiePizza extends Pizza {  
  4.     public ChicagoStyleVeggiePizza() {  
  5.         name = "Chicago Deep Dish Veggie Pizza";  
  6.         dough = "Extra Thick Crust Dough";  
  7.         sauce = "Plum Tomato Sauce";  
  8.    
  9.         toppings.add("Shredded Mozzarella Cheese");  
  10.         toppings.add("Black Olives");  
  11.         toppings.add("Spinach");  
  12.         toppings.add("Eggplant");  
  13.     }  
  14.    
  15.     public void cut() {  
  16.         System.out.println("Cutting the pizza into square slices");  
  17.     }  
  18. }  


/PizzaStore.java

此类也是声明为抽象的，实例化比萨的责任由具体的子类来实现
[java]  view plain copy
  1. package pizzafm;  
  2.   
  3.   
  4. /** 
  5.  * 让PizzaStore作为超类，让每个域类型都继承这个PizzaStore,每个子类各自决定如何制造披萨 
  6.  */  
  7. public abstract class PizzaStore {  
  8.     public Pizza orderPizza(String type) {  
  9.         Pizza pizza;  
  10.         pizza = createPizza(type);  
  11.           
  12.         pizza.prepare();  
  13.         pizza.bake();  
  14.         pizza.cut();  
  15.         pizza.box();  
  16.           
  17.         return pizza;  
  18.     }  
  19.       
  20.     abstract Pizza createPizza(String type);  
  21. }  

[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. public class NYPizzaStore extends PizzaStore {  
  4.   
  5.     @Override  
  6.     Pizza createPizza(String type) {  
  7.         if(type.equals("cheese")){  
  8.             return new NYStyleCheesePizza();  
  9.         } else if(type.equals("veggie")) {  
  10.             return new NYStyleVeggiePizza();  
  11.         } else if(type.equals("clam")) {  
  12.             return new NYStyleClamPizza();  
  13.         } else if(type.equals("pepperoni")){  
  14.             return new NYStylePepperoniPizza();  
  15.         } else return null;  
  16.     }  
  17.   
  18. }  


[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. public class ChicagoPizzaStore extends PizzaStore {  
  4.   
  5.     @Override  
  6.     Pizza createPizza(String type) {  
  7.         if(type.equals("cheese")) {  
  8.             return new ChicagoStyleCheesePizza();  
  9.         } else if(type.equals("veggie")) {  
  10.             return new ChicagoStyleVeggiePizza();  
  11.         } else if(type.equals("clam")) {  
  12.             return new ChicagoStyleClamPizza();  
  13.         } else return null;  
  14.     }  
  15.   
  16. }  

/PizzaTestDriver.java
[java]  view plain copy
  1. package pizzafm;  
  2.   
  3. /** 
  4.  * 工厂模式测试驱动类 
  5.  */  
  6. public class PizzaTestDriver {  
  7.     public static void main(String[] args) {  
  8.         //首先建立不同的店  
  9.         PizzaStore nyStore = new NYPizzaStore();  
  10.         PizzaStore chicagoStore = new ChicagoPizzaStore();  
  11.           
  12.         Pizza pizza = nyStore.orderPizza("cheese");  
  13.         System.out.println("Ethan ordered a " + pizza.getName() + "\n");  
  14.           
  15.         pizza = chicagoStore.orderPizza("cheese");  
  16.         System.out.println("Joel ordered a " + pizza.getName() + "\n");  
  17.     }  
  18. }  

抽象工厂模式实现







/Pizza.java

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public abstract class Pizza {  
  4.     String name;  
  5.     Dough dough;  
  6.     Sauce sauce;  
  7.     Veggies veggies[];  
  8.     Cheese cheese;  
  9.     Pepperoni pepperoni;  
  10.     Clams clam;  
  11.       
  12.     abstract void prepare();    //声明为抽象，在这个方法中那个我们需要搜集披萨所需的原料，而这些原料当然是来自原料工厂  
  13.       
  14.     void bake(){  
  15.         System.out.println("Bake for 25 minutes at 350");  
  16.     }  
  17.       
  18.     void cut() {  
  19.         System.out.println("Cutting the pizza into diagonal slices");  
  20.     }  
  21.   
  22.     void box() {  
  23.         System.out.println("Place pizza in official PizzaStore box");  
  24.     }  
  25.       
  26.     void setName(String name) {  
  27.         this.name = name;  
  28.     }  
  29.       
  30.     String getName() {  
  31.         return name;  
  32.     }  
  33.       
  34.     public String toString() {  
  35.         StringBuffer result = new StringBuffer();  
  36.         result.append("---- " + name + " ----\n");  
  37.         if (dough != null) {  
  38.             result.append(dough);  
  39.             result.append("\n");  
  40.         }  
  41.         if (sauce != null) {  
  42.             result.append(sauce);  
  43.             result.append("\n");  
  44.         }  
  45.         if (cheese != null) {  
  46.             result.append(cheese);  
  47.             result.append("\n");  
  48.         }  
  49.         if (veggies != null) {  
  50.             for (int i = 0; i < veggies.length; i++) {  
  51.                 result.append(veggies[i]);  
  52.                 if (i < veggies.length-1) {  
  53.                     result.append(", ");  
  54.                 }  
  55.             }  
  56.             result.append("\n");  
  57.         }  
  58.         if (clam != null) {  
  59.             result.append(clam);  
  60.             result.append("\n");  
  61.         }  
  62.         if (pepperoni != null) {  
  63.             result.append(pepperoni);  
  64.             result.append("\n");  
  65.         }  
  66.         return result.toString();  
  67.     }  
  68. }  


[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class CheesePizza extends Pizza {  
  4.     PizzaIngredientFactory ingredientFactory;  
  5.       
  6.     public CheesePizza(PizzaIngredientFactory ingredientFactory) {  
  7.         this.ingredientFactory = ingredientFactory;  
  8.     }  
  9.   
  10.   
  11.     @Override  
  12.     void prepare() {  
  13.         System.out.println("Preparing " + name);  
  14.         dough = ingredientFactory.createDough();  
  15.         sauce = ingredientFactory.createSauce();  
  16.         cheese = ingredientFactory.createCheese();  
  17.     }  
  18.   
  19. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class ClamPizza extends Pizza {  
  4.     PizzaIngredientFactory ingredientFactory;  
  5.       
  6.       
  7.     public ClamPizza(PizzaIngredientFactory ingredientFactory) {  
  8.         this.ingredientFactory = ingredientFactory;  
  9.     }  
  10.   
  11.     @Override  
  12.     void prepare() {  
  13.         System.out.println("PreParing " + name);  
  14.         dough = ingredientFactory.createDough();  
  15.         sauce = ingredientFactory.createSauce();  
  16.         cheese = ingredientFactory.createCheese();  
  17.         clam = ingredientFactory.createClam();  
  18.     }  
  19.   
  20. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class PepperoniPizza extends Pizza {  
  4.   
  5.     PizzaIngredientFactory ingredientFactory;  
  6.        
  7.     public PepperoniPizza(PizzaIngredientFactory ingredientFactory) {  
  8.         this.ingredientFactory = ingredientFactory;  
  9.     }  
  10.    
  11.     void prepare() {  
  12.         System.out.println("Preparing " + name);  
  13.         dough = ingredientFactory.createDough();  
  14.         sauce = ingredientFactory.createSauce();  
  15.         cheese = ingredientFactory.createCheese();  
  16.         veggies = ingredientFactory.createVeggies();  
  17.         pepperoni = ingredientFactory.createPepperoni();  
  18.     }  
  19. }  


[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class VeggiePizza extends Pizza {  
  4.     PizzaIngredientFactory ingredientFactory;  
  5.        
  6.     public VeggiePizza(PizzaIngredientFactory ingredientFactory) {  
  7.         this.ingredientFactory = ingredientFactory;  
  8.     }  
  9.    
  10.     void prepare() {  
  11.         System.out.println("Preparing " + name);  
  12.         dough = ingredientFactory.createDough();  
  13.         sauce = ingredientFactory.createSauce();  
  14.         cheese = ingredientFactory.createCheese();  
  15.         veggies = ingredientFactory.createVeggies();  
  16.     }  
  17.   
  18. }  


/PizzaIngredientFactory.java

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. /** 
  4.  * 建造原料工厂 
  5.  * 在接口中，每个原料都有一个对应的方法创造该原料 
  6.  */  
  7. public interface PizzaIngredientFactory {  
  8.     public Dough createDough();  
  9.     public Sauce createSauce();  
  10.     public Cheese createCheese();  
  11.     public Veggies[] createVeggies();  
  12.     public Pepperoni createPepperoni();  
  13.     public Clams createClam();  
  14. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. /** 
  4.  * 创建纽约原料工厂 
  5.  * 
  6.  */  
  7. public class NYPizzaIngredientFactory implements PizzaIngredientFactory {  
  8.   
  9.     @Override  
  10.     public Dough createDough() {  
  11.         return new ThinCrustDough();  
  12.     }  
  13.   
  14.     @Override  
  15.     public Sauce createSauce() {  
  16.         return new MarinaraSauce();  
  17.     }  
  18.   
  19.     @Override  
  20.     public Cheese createCheese() {  
  21.         return new ReggianoCheese();  
  22.     }  
  23.   
  24.     @Override  
  25.     public Veggies[] createVeggies() {  
  26.         Veggies veggies[] = {new Garlic(), new Onion(), new MushRoom(), new RedPepper()};  
  27.         return veggies;  
  28.     }  
  29.   
  30.     @Override  
  31.     public Clams createClam() {  
  32.         return new FreshClams();  
  33.     }  
  34.   
  35.     @Override  
  36.     public Pepperoni createPepperoni() {  
  37.         return new SlicePepproni();  
  38.     }  
  39.   
  40. }  


[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. /** 
  4.  * 芝加哥披萨原料工厂 
  5.  * 
  6.  */  
  7. public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {  
  8.   
  9.     @Override  
  10.     public Dough createDough() {  
  11.         return new ThickCrustDough();  
  12.     }  
  13.   
  14.     @Override  
  15.     public Sauce createSauce() {  
  16.         return new plumTomatoSauce();  
  17.     }  
  18.   
  19.     @Override  
  20.     public Cheese createCheese() {  
  21.         return new Mozzarella();  
  22.     }  
  23.   
  24.     @Override  
  25.     public Veggies[] createVeggies() {  
  26.         Veggies veggies[] = {new BlackOlives(), new Spinach(), new EggPlant()};  
  27.         return veggies;  
  28.     }  
  29.   
  30.     @Override  
  31.     public Clams createClam() {  
  32.         return new FrozenClams();  
  33.     }  
  34.   
  35.     @Override  
  36.     public Pepperoni createPepperoni() {  
  37.         return new SlicedPepperoni();  
  38.     }  
  39.   
  40. }  


所有原料接口，一系列产品族

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public interface Cheese {  
  4.     @Override  
  5.     public String toString();  
  6. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public interface Clams {  
  4.     @Override  
  5.     public String toString();  
  6. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public interface Dough {  
  4.     @Override  
  5.     public String toString();  
  6. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public interface Sauce {  
  4.     @Override  
  5.     public String toString();  
  6. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public interface Veggies {  
  4.     @Override  
  5.     public String toString();  
  6. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public interface Pepperoni {  
  4.     @Override  
  5.     public String toString();  
  6. }  


实现Cheese的类
[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class Mozzarella implements Cheese {  
  4.     public String toString() {  
  5.         return "Shredded Mozzarella";  
  6.     }  
  7. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class ReggianoCheese implements Cheese {  
  4.     public String toString() {  
  5.         return "Reggiano Cheese";  
  6.     }  
  7. }  

实现Clams的类
[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class FreshClams implements Clams {  
  4.     public String toString() {  
  5.         return "Fresh Clams from Long Island Sound";  
  6.     }  
  7. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class FrozenClams implements Clams {  
  4.     public String toString() {  
  5.         return "Frozen Clams from Chesapeake Bay";  
  6.     }  
  7. }  


实现Sauce的类
[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class MarinaraSauce implements Sauce {  
  4.     public String toString() {  
  5.         return "Marinara Sauce";  
  6.     }  
  7. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class plumTomatoSauce implements Sauce {  
  4.     public String toString() {  
  5.         return "Tomato sauce with plum tomatoes";  
  6.     }  
  7. }  

实现Veggies的类
[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class EggPlant implements Veggies {  
  4.     public String toString() {  
  5.         return "Eggplant";  
  6.     }  
  7. }  


[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class Onion implements Veggies {  
  4.     public String toString() {  
  5.         return "Onion";  
  6.     }  
  7. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class Spinach implements Veggies {  
  4.     public String toString() {  
  5.         return "Spinach";  
  6.     }  
  7. }  

[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class MushRoom implements Veggies {  
  4.     public String toString() {  
  5.         return "Mushrooms";  
  6.     }  
  7. }  



实现Pepperoni的类

实现Dough的类
[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class ThickCrustDough implements Dough {  
  4.     public String toString() {  
  5.         return "ThickCrust style extra thick crust dough";  
  6.     }  
  7. }  


[java]  view plain copy
  1. package pizzaaf;  
  2.   
  3. public class ThinCrustDough implements Dough {  
  4.     public String toString() {  
  5.         return "Thin Crust Dough";  
  6.     }  
  7. }  



关于工厂模式已经介绍完，蛮多内容的是吧。
什么时候用工厂方法和抽象方法呢？
来听听它们的告白：
抽象工厂：我是抽象工厂，当你需要创建产品家族和想让制造的相关产品集合起来时，你可以使用我。
工厂方法：我是工厂方法，我可以把你的客户代码从实例化的具体类中解耦。或者如果你目前还不知道将来需要实例化哪些具体类时，也可以用我。我的使用方式简单，只要把握继承成子类，并实现我的工厂方法就行了。
大西瓜M
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python工厂模式介绍、使用
captain
07-21 1210
上面的代码中，定义了一个抽象类 MyABC，其中包含一个抽象方法 do_something，这个方法在父类中只是一个声明，没有具体的实现。Python中的工厂模式是一种常用的创建型设计模式，其主要作用是封装对象的实例化过程，从而将客户端代码与具体类的实现分离开来，提高程序的可维护性和可扩展性。优点：工厂模式可以提高代码的灵活性和可维护性，客户端代码和具体类的实现之间松耦合，当需要新增或更改某个具体类时，只需要修改工厂类即可，无需修改客户端代码。（3）在客户端代码中，通过调用工厂类的工厂方法获取所需的对象。
python工厂模式_python 设计模式之工厂模式 Factory Pattern (简单工厂模式，工厂方法模式，抽象工厂模式)...
weixin_39571403的博客
11-30 221
十一回了趟老家，十一前工作一大堆忙成了狗，十一回来后又积累了一大堆又 忙成了狗，今天刚好抽了一点空开始写工厂方法模式我看了《Head First 设计模式》P109--P133 这25页，讲述了我们为什么要用工厂模式，里面用做pizza的例子讲的特别细腻。看完了就能很清楚的知道为什么要用工厂模式。年龄越大越不喜欢一知半解，深刻的了解某些未知的事或物以后，它再出现就不怕了#'New'有什么不对劲?在...
Python设计模式——工厂模式（Factory Pattern）
我的博客
08-27 410
import abc class Pizza(metaclass=abc.ABCMeta): name = '' toppings = [] def prepare(self): for i in self.toppings: print(i, end="") def bake(self): prin...
设计模式笔记（4） 工厂模式The Factory Pattern
铁锹的填坑记录
03-17 120
4_The Factory Pattern 问题引出 当使用new，正在实例化一个具体的类。这是一个类实现的过程。 我们使用接口类来接收我们使用new构造出来的一个具体实例，使用接口是为了让代码更加灵活。 Duck duck ; // Duck是一个接口。 if(picnic){ duck = new MallardDuck(); }else if(hunting){ duck ...
python设计模式之工厂模式(Factory Pattern)
mingo_敏
03-24 1040
工厂模式的本质就是用工厂方法代替new操作创建一种实例化对象的方式. import random from typing import Type class Pet: def __init__(self, name: str) -> None: self.name = name def speak(self) -> None: raise NotImplementedError def __str__(self) -> str
design-pattern-test:设计模式学习
04-30
工厂模式（Factory Pattern） 抽象工厂模式（Abstract Factory Pattern） 单例模式（Singleton Pattern） 建造者模式（Builder Pattern） 原型模式（Prototype Pattern） 2 结构型模式---这些设计模式关注类和...
abstract-factory-pattern
最新发布
03-06
Java开发者：无论您是初学者还是资深开发者，都可以从本文中学习到抽象工厂模式的相关知识，提升代码设计水平。 对设计模式感兴趣的人：如果您对设计模式感兴趣，想要深入了解Java中的设计模式，那么本文将是您...
Factory-Pattern:使用JAVA的工厂设计模式
05-05
使用JAVA的工厂模式 什么是工厂 当该方法返回共享一个公共超类的几个可能的类中的一个时 在运行时选择该类 何时使用 当您现在不提前使用所需的类对象时 当所有潜在类都在同一子类层次结构中时 集中班级选择模式 当您...
PHP设计模式之工厂模式(Factory Pattern)的讲解
01-20
通常工厂模式有一个关键的构造，即一般被命名为factory的静态方法。这个静态方法可以接受任意数量的参数，并且必须返回一个对象。 一个非常贴近生活的例子来告诉你什么是工厂模式 但是工厂模式真的是个累赘吗？其实...
C#设计模式（4）－Simple Factory Pattern
[木子]的专栏
06-10 858
工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。工厂模式有以下几种形态： 简单工厂（Simple Factory）模式 工厂方法（Factory Method）模式 抽象工厂（Abstract Factory）模式  一、 简单工厂（Simple Factory）模式Simpl
Java设计模式之工厂方法模式（Factory Pattern）
落队的飞行兵
08-14 483
介绍 工厂模式属于创建类设计模式中非常基础的一种，对于它的定义是这样的： Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclas...
设计模式（四）The Factory Pattern 工厂模式
francisshi的专栏
10-19 996
一、简单工厂 定义：定义一个创建对象的接口，但是由其子类决定要实例化的对象是哪一个，工厂方法让类的实例化推迟到子类。 通俗的来讲就是由工厂方法确定一个框架，具体的实现由其子类来完成。与简单工厂相比，简单工厂可是完成了整个对象的创建。      严格的来说简单工厂并不是一种设计模式，他更像是一种编程习惯。 代码说明一切！ 1、这是一个简单工厂
工厂模式（Factory Pattern）简介
weixin_43183107的博客
08-20 210
简单工厂模式 简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于GOF23种设计模式。简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。简单工厂也有它的缺点：工厂类的职责相对过重，不易于扩展过于复杂的产品结构。 代码示例如下： public interface ICourse { void record(); } public class JavaCour
设计模式 一 工厂模式（The Factory Pattern）
每天进步一点点
03-09 679
工厂模式有三种：简单工厂（simple factory）、工厂方法(factory method)、抽象工厂(abstract factory)。 一、简单工厂（simple factory）       1、simple factory 模式的工厂类根据提供给他的参数，返回几个可能产品类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法。       2、simpl
设计模式 - 工厂模式(factory pattern) 详解
Mystra
05-26 3745
工厂模式(factory pattern) 详解 本文地址:http://blog.csdn.net/caroline_wendy/article/details/27081511 工厂方法模式: 定义了一个创建对象的接口, 但由子类决定要实例化的类是哪一个. 工厂方法让类把实例化推迟到子类.包括:创建者父类(creator), 包含创建对象的方法(代替new具体的对象, 通过参数创建不同的对象), 和一些基本的方法;具体创建者(concrete
Python实现设计模式--02.工厂模式（Factory Pattern）
贤弟
07-26 6096
《设计模式》涉及到创建类的几种模式，共同的也是最根本的原则就是：不要new 对象！！！既然如此，告诉我你最先想到的是如何得到对象呢？没错，“你不让我new，那你给我个get对象的工具吧，别的我不管”。这就是工厂模式，工厂模式是一种简单又实用的模式，在各大框架到处可见，比如Java世界大名鼎鼎的spring，其本身就是一个大工厂。 工厂模式中，工厂的作用是解耦调用者和被调用者的关系，工厂模式又分为工厂方法模式和简单工厂模式。
Android设计模式之一个例子让你彻底明白工厂模式(Factory Pattern)
热门推荐
阿拉灯神灯的专栏
12-29 1万+
提出疑问这几天研究工厂模式的时候，看到网上的一些文章中举的例子我就很疑惑，我相信这也是许多人的疑惑：工厂模式的功能就是创建实例，我们创建实例直接new不就完了吗，干嘛还得再封装一层工厂类，然后用工厂类再去new出这个实例？这不多此一举吗？比如我看到这样的例子，我们的用户分为金牌用户和银牌用户，我们要创建一个金牌用户或者银牌用户。定义一个用户接口public interface ICustomer {
工厂模式（Factory Pattern）：简单&粗暴解析
qwe851023的博客
11-10 370
1.前言 在之前的文章设计模式(Design pattern)：简单&amp;粗暴解析中已经为大家深入浅出解析了 设计模式 的 七大原则、三大类型。 本文为大家解析三大类型中 创建型 里其中的 工厂模式。 文章中实例&nbsp; linhaojian的Github 2.目录 3.含义 简单工厂模式的扩展，设立不同的子工厂，创建对应的一个对象。 4.解决 1.“使用实例者”和“实...
设计模式之工厂模式（factory pattern）
06-10
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们定义一个接口或抽象类，它代表了创建对象的工厂，而具体的对象创建则由其子类来完成。这样就可以将对象的创建和使用分离开来，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值