【设计模式】02-HeadFirst工厂模式

最新推荐文章于 2021-12-24 23:09:01 发布

一直不懂

最新推荐文章于 2021-12-24 23:09:01 发布

阅读量207

点赞数

分类专栏：设计模式

设计模式专栏收录该内容

8 篇文章

订阅专栏

本文通过制作Pizza的例子详细解析了简单工厂模式与工厂方法模式。简单工厂模式将创建对象的逻辑封装在一个静态方法中，而工厂方法模式则通过定义一个创建对象的接口，允许子类决定实例化哪一个类。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转自 http://blog.youkuaiyun.com/u010800530/article/details/45801353

设计模式要求我们不应该针对实现编程，是为了降低耦合度，提高可维护性。当程序中出现“new”的时候，就证明程序在实例化一个具体类，所以用的是实现，而不是接口。如果代码绑着具体的类会导致代码更加脆弱，缺乏弹性。比如，需要创建一“个鸡蛋饼”这个对象，首先需要创建一个饼，然后创建一个鸡蛋，再然后把鸡蛋摊在饼上边，然后给饼翻翻，几分钟后就出炉了....（有点饿）。在这种情况下，新对象的建立是一个过程，如果我们需要在这个饼上边抹点辣椒酱，那肯定需要对类进行修改，违反了“对扩展开放，对修改关闭”的设计原则。这样就出现了一个问题：

如何让客户直接构造出对象的实例，而不用在乎构造对象实例的具体细节？（就比如说，我想吃鸡蛋饼，直接就能买到，不需要知道这个鸡蛋饼如何做出来的）

具体实现：

首先，我们需要知道，工厂模式包含了三种：简单工厂（静态工厂）、工厂方法、抽象工厂。但是简单工厂并不属于GOF的23种设计模式

下边会用制作Pizza的例子来对三个模式进行说明：

假设你有一个Pizza店，并且你有很多种类型的Pizza，那么你会这样写代码：

[java]view plain copy
Pizza orderPizza(String type){  
        Pizza pizza;  
          
        if(type.equals("chesse")){  
            pizza = new CheesePizza();  
        }else if(type.equals("greek")){  
            pizza = new GreekPizza();  
        }else if(type.equals("pepperoni")){  
            pizza = new PepperoniPizza();  
        }  
          
        pizza.prepare();  
        pizza.bake();  
        pizza.cut();  
        pizza.box();  
        return pizza;  
    }  

根据参数传入类型type的不同，实例化不同的Pizza。

但是，你的竞争对象已经在菜单中加入了其它流行风味Pizza：ClamPizza（蛤蜊披萨）、VeggiePizza（素食披萨）。如果你想要赶上他们你就必须在自己的菜单中加入这些风味的披萨，而GreekPizza（希腊披萨）因为卖的不好所以去掉：

很明显的，orderPizza()方法不能够使得对修改关闭，但是我们已经知道哪些会改变，哪些不会改变，就可以使用封装了。

一、简单工厂模式：

要把创建Pizza的代码移动到另一个对象中，由这个新对象专职创建Pizza：

[java]view plain copy
public class SimplePizzaFactory {  
    public Pizza createPizza(String type) {  
        Pizza pizza = null;  
  
        if (type.equals("cheese")) {  
            pizza = new CheesePizza();  
        } else if (type.equals("pepperoni")) {  
            pizza = new PepperoniPizza();  
        } else if (type.equals("clam")) {  
            pizza = new ClamPizza();  
        } else if (type.equals("veggie")) {  
            pizza = new VeggiePizza();  
        }  
        return pizza;  
    }  
}  

问题：这么做似乎是把问题搬到另一个对象罢了？似乎没有什么好处？

答：SimplePizzaFactory可以有许多的客户，虽然目前仅仅只有orderPizza()方法是它的客户，但是在以后的扩展过程中可能会有很多个客户（但是如果把createPizza()这个方法放入到orderPizza()方法中的话，它只可能为orderPizza()一个服务）。所以，把创建Pizza的代码包装进一个类后，当以后实现改变的话，只需要修改这个类即可。我们正需要做的就是把实例化的过程，从客户的代码中删除。

缺点：因为是静态的，不能够通过继承来改变创建方法的行为。

下边，我们把其它的类写出来：

PizzaStore：是SimplePizzaFactory工厂类的“客户”，PizzaStor通过工厂类取得Pizza的实例

[java]view plain copy
public class PizzaStore {  
    SimplePizzaFactory factory;  
  
    public PizzaStore(SimplePizzaFactory factory) {  
        this.factory = factory;  
    }  
  
    public Pizza orderPizza(String type) {  
        Pizza pizza;  
  
        pizza = factory.createPizza(type);  
  
        pizza.prepare();  
        pizza.bake();  
        pizza.cut();  
        pizza.box();  
  
        return pizza;  
    }  
}  

Pizza：工厂的产品

[java]view plain copy
abstract public class Pizza {  
    String name;  
    String dough;  
    String sauce;  
    ArrayList<String> toppings = new ArrayList<String>();  
  
    public String getName() {  
        return name;  
    }  
  
    public void prepare() {  
        System.out.println("Preparing " + name);  
    }  
  
    public void bake() {  
        System.out.println("Baking " + name);  
    }  
  
    public void cut() {  
        System.out.println("Cutting " + name);  
    }  
  
    public void box() {  
        System.out.println("Boxing " + name);  
    }  
  
    public String toString() {  
        StringBuffer display = new StringBuffer();  
        display.append("---- " + name + " ----\n");  
        display.append(dough + "\n");  
        display.append(sauce + "\n");  
        for (int i = 0; i < toppings.size(); i++) {  
            display.append(toppings.get(i) + "\n");  
        }  
        return display.toString();  
    }  
}  

CheesePizza：

[java]view plain copy
public class CheesePizza extends Pizza {  
    public CheesePizza() {  
        name = "Cheese Pizza";  
        dough = "Regular Crust";  
        sauce = "Marinara Pizza Sauce";  
        toppings.add("Fresh Mozzarella");  
        toppings.add("Parmesan");  
    }  
}  

VeggiePizza：

[java]view plain copy
public class VeggiePizza extends Pizza {  
    public VeggiePizza() {  
        name = "Veggie Pizza";  
        dough = "Crust";  
        sauce = "Marinara sauce";  
        toppings.add("Shredded mozzarella");  
        toppings.add("Grated parmesan");  
        toppings.add("Diced onion");  
        toppings.add("Sliced mushrooms");  
        toppings.add("Sliced red pepper");  
        toppings.add("Sliced black olives");  
    }  
}  

ClamPizza：

[java]view plain copy
public class ClamPizza extends Pizza {  
    public ClamPizza() {  
        name = "Clam Pizza";  
        dough = "Thin crust";  
        sauce = "White garlic sauce";  
        toppings.add("Clams");  
        toppings.add("Grated parmesan cheese");  
    }  
}  

写一个Main类：PizzaTestDrive

[java]view plain copy
public class PizzaTestDrive {  
  
    public static void main(String[] args) {  
        SimplePizzaFactory factory = new SimplePizzaFactory();  
        PizzaStore store = new PizzaStore(factory);  
  
        Pizza pizza = store.orderPizza("cheese");  
        System.out.println("We ordered a " + pizza.getName() + "\n");  
  
        pizza = store.orderPizza("veggie");  
        System.out.println("We ordered a " + pizza.getName() + "\n");  
    }  
}  

把UML类图画出来了：

二、工厂方法模式

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

现在，大家都希望能够在自家附近加盟你开的披萨店（其实就是想用你的招牌在他们那里开店啦）。但是，每个区域都会有差异，每家加盟店都想要提供不同风味的比萨（比方说纽约、芝加哥、加州），你想这样做：

[java]view plain copy
//纽约风味的素食Pizza  
NYPizzaFactory nyFactory = new NYPizzaFactory();  
PizzaStore nyStore = new PizzaStore(nyFactory);  
nyStore.orderPizza("Veggie");  
  
//芝加哥风味的素食Pizza  
ChicagePizzaFactory chicagoFactory = new ChicagePizzaFactory();  
PizzaStore chicagoStore = new PizzaStore(chicagoFactory);  
chicagoStore.orderPizza("Veggie");  

问题：但是，在推广你的方法的时候，别的加盟店的确是采用你的工厂创建比萨，但是其他部分却开始此采用他们自创的流程：烘烤的做法有差异、不要切片、使用其他厂商的盒子等等。

有一种做法可以让比萨制作活动局限于PizzaStore类，而同时又能让这些加盟店依然可以自由的制作本地区域的风味：

把createPizza()方法放回到PizzaStore中，不过要把它设置成“抽象方法”：（原本是由一个对象负责所有具体类的实例化，现在通过对PizzaStor做一些转变，变成由一群子类来负责实例化）

声明一个工厂类：

[java]view plain copy
public abstract class PizzaStore {  
    //把createPizza()方法设置成抽象的，由子类做决定  
    abstract Pizza createPizza(String item);  
      
    public Pizza orderPizza(String type) {  
        Pizza pizza = createPizza(type);  
        System.out.println("--- Making a " + pizza.getName() + " ---");  
          
        pizza.prepare();  
        pizza.bake();  
        pizza.cut();  
        pizza.box();  
        return pizza;  
    }  
}  

然后声明两个具体工厂类：NYPizzaStore、ChicagoPizzaStore：

[java]view plain copy
public class NYPizzaStore extends PizzaStore {  
    Pizza createPizza(String item) {  
        if (item.equals("cheese")) {  
            return new NYStyleCheesePizza();  
        } else if (item.equals("veggie")) {  
            return new NYStyleVeggiePizza();  
        } else if (item.equals("clam")) {  
            return new NYStyleClamPizza();  
        } else if (item.equals("pepperoni")) {  
            return new NYStylePepperoniPizza();  
        } else return null;  
    }  
}  

[java]view plain copy
public class ChicagoPizzaStore extends PizzaStore {  
    Pizza createPizza(String item) {  
            if (item.equals("cheese")) {  
                    return new ChicagoStyleCheesePizza();  
            } else if (item.equals("veggie")) {  
                    return new ChicagoStyleVeggiePizza();  
            } else if (item.equals("clam")) {  
                    return new ChicagoStyleClamPizza();  
            } else if (item.equals("pepperoni")) {  
                    return new ChicagoStylePepperoniPizza();  
            } else return null;  
    }  
}  

我们需要建立一个Pizza实体类：

[java]view plain copy
public abstract class Pizza {  
    String name; //名称  
    String dough; //面团类型  
    String sauce; //酱料  
    ArrayList<String> toppings = new ArrayList<String>(); //作料  
  
    void prepare() {  
        System.out.println("准备 " + name);  
        System.out.println("揉面团...");  
        System.out.println("添加酱料...");  
        System.out.println("添加作料: ");  
        for (int i = 0; i < toppings.size(); i++) {  
            System.out.println("   " + toppings.get(i));  
        }  
    }  
    void bake() {  
        System.out.println("烘烤25分钟");  
    }  
    void cut() {  
        System.out.println("把Pizza对角切片");  
    }  
    void box() {  
        System.out.println("把Pizza装盒子");  
    }  
    public String getName() {  
        return name;  
    }  
}  

然后需要一些具体的子类，下边定义两个子类：纽约风味的芝士披萨（NYStyleCheesePizza）、芝加哥风味的芝士披萨(ChicageStyleCheesePizza)

[java]view plain copy
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");  
    }  
}  

[java]view plain copy
public class ChicagoStyleCheesePizza extends Pizza {  
    public ChicagoStyleCheesePizza() {   
        name = "Chicago Style Deep Dish Cheese Pizza";  
        dough = "Extra Thick Crust Dough";  
        sauce = "Plum Tomato Sauce";  
   
        toppings.add("Shredded Mozzarella Cheese");  
    }  
    //可以覆盖cut()方法  
    void cut() {  
        System.out.println("Cutting the pizza into square slices");  
    }  
}  