读headFirst设计模式 - 工厂模式

每次写博客都不知道要怎么引入要写的主题,挺头疼的一件事。今天就直接开门见山,今天要学的就是工厂模式,工厂就是批量生产制造东西的地方。在这里,工厂就是批量生产对象的地方。

 

学习书上的例子

假如你现在有一个披萨店PizzaStore,店里有各种各样的pizza,现在你需要根据订单生产pizza,可能会这样做

    public Pizza orderPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese"))
            pizza = new CheesePizza();
        else 
            pizza = new GreekPizza();
    }

将具体需要哪种pizza直接放在orderPizza方法中,那需要增加新的pizza呢……好吧,这里先跳过,先看一下如果使用简单工厂要怎么做。(书上说简单工厂不算一个“真正的”模式,更像一种编程习惯,好吧,这个我们就不纠结了)需要一个专门生产pizza的类SimplePizzaFactory,把生产pizza的任务就交给它了,就像这样:

/**
 * 专门生产pizza的工厂
 */
public class SimplePizzaFactory {
    public static Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese"))
            pizza = new CheesePizza();
        else 
            pizza = new GreekPizza();
        return pizza;
    }
}

好了,得到了想要的pizza,现在接着完成pizza的订单,还需要这样的几个步骤:准备prepare(), 烘烤bake(), 切片cut(), 装盒box(). 这几个方法对所有pizza都是一样的, 所以需要一个pizza的抽象类,这几个方法可以直接在这个抽象类中实现

public abstract class Pizza {
    public void prepare() {
        System.out.println("prepare");
        description();
    }
        
    public void bake() {
        System.out.println("bake");
    }
    public void cut() {
        System.out.println("cut");
    }
    public void box() {
        System.out.println("box");
    }
    public abstract void description();//描述pizza
}

 

具体的pizza(如cheesePizza)继承这个Pizza这个类,在description方法中添加自己的描述

public class CheesePizza extends Pizza {    
    @Override
    public void description() {
        System.out.println("default NY Cheese Pizza");
    }

}

 

其他的我就不写了,现在可以用工厂生产pizza了,这时候orderPizza方法大概就是这样的

public class PizzaStore {
    public Pizza orderPizza(String type) {
        Pizza pizza = SimplePizzaFactory.createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

你可能会问,这不就是把问题从一个地方搬到了另一个地方吗,问题依然存在啊。是的,我开始也是这样想的,但是仔细想想,这样还是有好处的,如果说其他的类中也需要生产pizza呢?难道你还要在把生产pizza的代码写一遍?用书上表达意思就是简单工厂SimplePizzaFactory的客户可能还有其他的,就是说在其他的类中也需要生产pizza。所以说需要依据具体情况创建对象时简单工厂是一个好的选择。

 

书上把工厂模式分成了3类(我这里把简单工厂也当作一类),分别是简单工厂,工厂方法和抽象工厂,简单工厂上面已经介绍了,然后看一下工厂方法和抽象工厂

 

工厂方法

现在pizza店的生意比较好,准备开加盟店了,在纽约和芝加哥等地方开一些加盟店,就有了NYPizzaStore和ChicagoPizzaStore等,可是由于地域差异造成了人们的口味也不同,就是说同一种pizza的风味都不一样,比如纽约的cheesePizza的饼要厚一些,而芝加哥的cheesePizza的饼要薄一些。这样就不能使用简单工厂呢?先不作回答,接着往下看,由于各个地方的pizza的风味不一样,所以让他们自己制造自己的pizza,就在PizzaStore中写一个抽象的制作pizza的方法

public abstract Pizza createPizza(String type);

然后在orderPizza中调用这个方法就可以得到想要的pizza,原来的简单工厂就可以替换为

Pizza pizza = createPizza(type);

具体的pizza店(如NYPizzaStore和ChiragoPizzaStore)继承自抽象的pizza店PizzaStore,然后实现各自制作pizza的方法createPizza,比如像这样

NYPizzaStore

    //默认为纽约风味的pizza
    @Override
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese"))
            pizza = new CheesePizza();
        else 
            pizza = new GreekPizza();
        return pizza;
    }

 

ChiragoPizzaStore

    @Override
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new ChicagoCheesePizza();
        }
        else 
            pizza = new ChicagoGreekPizza();
        return pizza;
    }

 

可以测试一下

        ChicagoPizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
        chicagoPizzaStore.orderPizza("cheese");

可以看到,不同pizza店生产不同的pizza,都是依靠public abstract Pizza createPizza(String type);这个方法,能够生产不同的pizza,就像一个工厂一样。所以把这个方法称为工厂方法。工厂方法都是要返回一个具体的产品的。

 

工厂方法模式的定义

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

 

还没有完,可以看到,2个具体的pizza店都是负责创建pizza的,于是我就想能不能把这2个pizza店创建pizza的动作交给一个简单工厂来处理,就像这样

public class NoSimplePizzaFactory {
    //通过pizza店clazz来区分地域
    public static Pizza createPizza(Classextends PizzaStore> clazz, String type) {
        if (clazz == null)
            throw new NullPointerException("address不能为空");
        if (StringUtils.isNullOrEmpty(type))
            throw new NullPointerException("type不能为空");
        
        if (clazz.getSimpleName().equals(NYPizzaStore.class.getSimpleName())) {
            if (type.equals("cheese"))
                return new CheesePizza();
            else
                return new GreekPizza();
        } else if (clazz.getSimpleName().equals(ChicagoPizzaStore.class.getSimpleName())) {
            if (type.equals("cheese"))
                return new ChicagoCheesePizza();
            else 
                return new ChicagoGreekPizza();
        } else
            return null;
    }
}

于是在具体的pizza店中调用制作pizza的方法就可以得到pizza了

NoSimplePizzaFactory.createPizza(getClass(), type);

再来看一下刚才提出的问题:能不能在抽象类PizzaStore中使用简单工厂来制作各地区不同的pizza?答案是可以的,因为我们现在有了一个简单工厂NoSimplePizzaFactory(简单工厂不简单啊),它可以生产各地区不同的pizza。所以来一个重载的orderPizza方法或把原来的orderPizza方法修改一下,就像这样

    public Pizza orderPizza(Classextends PizzaStore> clazz, String type) {
        Pizza pizza = NoSimplePizzaFactory.createPizza(clazz, type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

这样就可以制作不同地区不同的pizza了。

 

现在pizza店的生意越来越好了,随机而来的问题是制作pizza的原料供不应求,而且各个地区的pizza所用的原料还可能不同,如图

读headFirst设计模式 - 工厂模式_第1张图片

为了解决原料供不应求和各地制作pizza所用原料不同的问题,我们可以在每个地区都建一座原料工厂。来供应本地区pizza店所需要的原料。新建一个抽象的原料工厂PizzaIngredientFactory,里面有制造原料的方法,比如:

    Dough createDough();
    Sauce createSauce();

这个工厂是一个接口,然后2个具体的原料工厂ChicagoPizzaIngredientFactory和NYPizaaIngredientFactory实现它,不同的工厂制作不同的原料,

ChicagoPizzaIngredientFactory

    @Override
    public Dough createDough() {
        return new ChicagoDough();
    }

    @Override
    public Sauce createSauce() {
        return new ChicagoSauce();
    }

 

NYPizaaIngredientFactory

    @Override
    public Dough createDough() {
        return new NYDough();
    }

    @Override
    public Sauce createSauce() {
        return new NYSauce();
    }

 

现在在pizza中加入这些原料,也就是在Pizza类中加入原料属性

    Dough dough;    //面团
    Sauce sauce;    //酱料

大家还可以自己添加其他的原料属性,这些原料是工厂生产的,所以把工厂也放在Pizza类中

    private PizzaIngredientFactory ingredientFactory;
    public Pizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

然后在具体的pizza中添加对应的构造方法,然后在准备prepare阶段生产原料,所以prepare方法修改一下

    public void prepare() {
        System.out.println("prepare");
        description();
        if (ingredientFactory != null) {
            dough = ingredientFactory.createDough();
            sauce = ingredientFactory.createSauce();
            System.out.println(dough.getName());
            System.out.println(sauce.getName());
        }
    }

然后在简单工厂NoSimplePizzaFactory中就可以使用原料工厂了,然后在该类中引入原料工厂

    private static PizzaIngredientFactory chicagoPizzaIngredientFactory = new ChicagoPizzaIngredientFactory();
    private static PizzaIngredientFactory nyPizaaIngredientFactory = new NYPizaaIngredientFactory();

然后创建pizza是注入工厂,修改其中的即可

        if (clazz.getSimpleName().equals(NYPizzaStore.class.getSimpleName())) {
            if (type.equals("cheese"))
                return new CheesePizza();
            else
                return new GreekPizza(nyPizaaIngredientFactory);

 

测试一下,你会发现可以通过工厂获得不同的pizza。本例只为说明工厂模式,所以还有不足之处,例如,一旦确定了pizza的区域和种类,通过orderPizza方法得到的pizza就是确定的,并不能在动态的改变制作pizza的原料,我的思路:只要控制原料工厂就可以在制作pizza时动态的改变原料。

 

从本例可以看到,pizza原料工厂就是一个抽象工厂

 

抽象工厂模式的定义

提供一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。

 

工厂方法是不是潜伏在抽象工厂里面

可以看到PizzaIngredientFactory接口中有2个制造原料的抽象方法,这2个方法的作用是生产原料,所以这2个是工厂方法。

 

小结

简单工厂专职创建对象

工厂方法是一个生产产品的抽象方法,具体生产什么产品由具体的子类决定

抽象工厂用于制造产品的“家族”,具体产品家族由具体工厂决定,抽象工厂里的方法通常是工厂方法

 

你可能感兴趣的:(读headFirst设计模式 - 工厂模式)