HeadFirst设计模式读书笔记之工厂模式

1. 简单工厂

1. 你开了一家披萨店,点披萨的方法可能是这样:

    public Pizza orderPizza(String type) {
        Pizza pizza;
        if (type.equals("芒果披萨")){
            pizza = new MangoPizza();
        }else if (type.equals("核桃披萨")){
            pizza = new WalnutPizza();
        }else if (type.equals("橙皮披萨")){
            pizza = new FlavedoPizza();
        }else {
            pizza = new StarPizza();
        }

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

可以看到,每当你想增加一种披萨类型,就要修改代码,添加一种if else条件.当有多个系统存在orderPizza的需求时,每个系统都要同时修改他们的代码.因此,需要将这种实例化具体对象的代码封装起来.

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;
    }
}

public class SimplePizzaFactory {

    public Pizza createPizza(String type){
        Pizza pizza = null;
        
        if (type.equals("芒果披萨")){
            pizza = new MangoPizza();
        }else if (type.equals("核桃披萨")){
            pizza = new WalnutPizza();
        }else if (type.equals("橙皮披萨")){
            pizza = new FlavedoPizza();
        }else {
            pizza = new StarPizza();
        }
        
        return pizza;
    }
}

这就是简单工厂方法,他不算一种设计模式,而是一种编程习惯.其要点有二:

1. 将产品定义为抽象类,可以被覆盖

2. 将具体的产品放到工厂类中来实例化,由工厂创建并返回给客户,这样便使得产品的创建逻辑可以解耦合,并增加了复用性

2. 工厂方法

1. 假设你现在有了很多加盟店,每种加盟店根据地区的差异有自己的工厂,但加盟店虽然采用工厂方法创建披萨,但其他部分却有所不同:烘烤的做法,不切片,使用杂七杂八的盒子...

这时,你想把创建披萨的方法与每家披萨店绑定在一起,让每家PizzaStore中都使用createPizza()创建pizza,并且这些店还可以拥有一定的制作披萨的自主权.因此,我们需要把PizzaStore和createPizza()定义成抽象的

/**
 * 抽象的PizzaStore
 */
public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza;
        // 使用自己的方法做披萨
        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

    // 将做披萨的工厂方法放到PizzaStore中,工厂方法是抽象的,所以依赖子类来处理对象的创建
    public abstract Pizza createPizza(String type);
}

2. 现在由PizzaStore的子类来具体卖披萨

public class BeijingPizzaStore extends PizzaStore {
    @Override
    public Pizza createPizza(String item) {
        if (item.equals("橙皮披萨")){
            return new FlavedoPizza();
        }else {
            return new PekingDuckPizza();
        }
    }
}

public class ChengduPizza extends PizzaStore {
    @Override
    public Pizza createPizza(String type) {
        if (type.equals("芒果披萨")){
            return new MangoPizza();
        }else {
            return new StarPizza();
        }
    }
}

现在,orderPizza()与具体的Pizza实现了一定的解耦合,决定最终Pizza对象的变成了某个具体的pizza店,而pizza店则由顾客来决定

3. 一些对工厂方法的理解:

1. 工厂方法是抽象的,所以依赖子类来创建对象,这样便将超类的代码与具体创建产品的代码分割开了

2. 工厂方法必须返回一个产品,超类通常中会用到这个产品

3. 工厂方法将产品与创建者抽象为接口,使他们成为平级的存在,具体的产品创建则使用子类来交互

4. 工厂方法将产品实例化的操作推迟到子类,子类的选择则由创建者来决定

5. 简单工厂方法更趋向组合,工厂方法则利用抽象和继承

6. 简单工厂封装了对象的创建,一个工厂处理所有的产品,但对同一个产品不可变更其做法,工厂方法则更有弹性,子类通过重写可以更改产品的创建

3. 依赖倒置原则

下面是一个简单粗暴的披萨店:

/**
 * 依赖具体对象的PizzaStore
 */
public class PizzaStore {
    
    public Pizza createPizza(String style, String type){
        Pizza pizza = null;
        if (style.equals("一元档")){
            if (type.equals("芒果披萨")){
                pizza = new MangoPizza();
            }else if (type.equals("核桃披萨")){
                pizza = new WalnutPizza();
            }
        }else if (style.equals("二元档")){
            if (type.equals("北京烤鸭披萨")){
                pizza = new PekingDuckPizza();
            }else if (type.equals("橙皮披萨")){
                pizza = new FlavedoPizza();
            }
        }else {
            System.out.println("披萨卖完了");
        }
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

可以看到,这个披萨店依赖于每一个具体的披萨对象,每增加一个披萨就要修改一次代码,增加一个依赖,可以说是非常不好用了

从图中看到,高层组件直接依赖于低层组件而依赖倒置原则的的内容就是:

要依赖抽象,不要依赖具体类
这个原则说明不管高层还是低层组件都不应该依赖具体类,而应该依赖于抽象.如图所示:

与之前相比高层组件PizzaStore不在直接依赖于具体的Pizza对象,而是依赖于Pizza接口,而具体的Pizza产品则由被高层组件依赖颠倒成了依赖Pizza接口,这就是一种依赖倒置.总体来看,PizzaStore和Pizza都抽象化了,不用再依赖于具体的类型,符合依赖倒置的设计原则.
有三个指导方针可以让你更好地遵守依赖倒置原则:

• 变量不可以持有具体类的引用
• 不要让类派生自具体类
• 不要覆盖基类中已覆盖的方法

4. 抽象工厂方法:创建产品家族

与普通的工厂方法比较,抽象工厂方法要显得重型得多: 工厂方法只创建一种产品,抽象工厂方法则创建一个家族的产品

1. 典型做法是创建一个工厂的接口,这个接口负责创建所有的产品家族成员,如创建一个生产调料家族的工厂:

/**
* 原料工厂的接口,实现这样的接口,可以随意组合产出各式各样的调料
* 每个原料都是一个类
*/
public interface SeasoningFactory {

   Chili createChili();
   
   DouBan createDouBan();
   
   Pepper createPepper();
   
   Salt createSalt();

}

/**
 * 郫县调料生产厂
 */
public class PiXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 郫县豆瓣
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new PiXianDouBan();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用盐
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}

/**
 * 灌县调料生产厂
 */
public class GuanXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 老干妈豆瓣酱
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new LaoGanMaDouBanJiang();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用盐
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}

下面是抽象工厂方法的类图:

从类图中可以看出来,抽象工厂方法有一个缺点,就是当添加了一个新产品接口时,要去抽象工厂接口中添加一个方法,这会造成一些麻烦

2. 工厂方法与抽象工厂的一些对比

相同点:

• 都是负责创建对象
• 都能使程序解耦,将程序从创建大量具体对象的泥潭中拉出来

不同点:

• 工厂方法用子类来创建具体对象,利用抽象和继承.抽象工厂包含了一大堆接口,利用组合的思想来创建对象
• 工厂方法一般用来创建一种产品,抽象工厂则创建一族产品
• 工厂方法功能简单,使用轻便.抽象工厂功能强大,使用时会创建大量的类

3. 下面使用抽象工厂生产的原料来制作披萨

/**
 * 原料工厂的接口,实现这样的接口,可以随意组合产出各式各样的调料
 * 每个原料都是一个类
 */
public interface SeasoningFactory {

    /**
     * 辣椒
     * @return
     */
    Chili createChili();

    /**
     * 豆瓣
     * @return
     */
    DouBan createDouBan();

    /**
     * 花椒
     * @return
     */
    Pepper createPepper();

    /**
     * 盐
     * @return
     */
    Salt createSalt();

}

/**
 * 豆瓣
 */
public abstract class DouBan {
    public abstract String sayMyName();
}

public class PiXianDouBan extends DouBan {
    @Override
    public String sayMyName() {
        return "郫县豆瓣";
    }
}

public class LaoGanMaDouBanJiang extends DouBan {
    @Override
    public String sayMyName() {
        return "老干妈豆瓣酱";
    }
}

/**
 * 郫县调料生产厂
 */
public class PiXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 郫县豆瓣
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new PiXianDouBan();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用盐
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}

/**
 * 灌县调料生产厂
 */
public class GuanXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 老干妈豆瓣酱
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new LaoGanMaDouBanJiang();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用盐
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}

/**
 * 每一个披萨都有一组抽象工厂生产的原料
 *
 */
public abstract class Pizza {

    protected String name;

    /**
     * 辣椒
     */
    protected Chili chili;

    /**
     * 豆瓣
     */
    protected DouBan douBan;

    /**
     * 花椒
     */
    protected Pepper pepper;

    /**
     * 盐
     */
    protected Salt salt;


    /**
     * 在这个方法中,收集抽象工厂生产的原料
     */
    public abstract void prepare();

    public void bake(){
        System.out.println("烘烤...");
    }

    public void cut(){
        System.out.println("切片...");
    }

    public void box() {
        System.out.println("包装...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString(){
         return "披萨制作完毕:"+name
        +"
生产原料:"+chili.sayMyName()
                +"	"+douBan.sayMyName()
                +"	"+pepper.sayMyName()
                +"	"+salt.sayMyName();

    }
}

public class ChengduPizza extends Pizza{

    // 调料工厂
    SeasoningFactory seasoningFactory;

    public ChengduPizza(SeasoningFactory seasoningFactory) {
        this.name = "旧成都披萨";
        this.seasoningFactory = seasoningFactory;
    }

    @Override
    public void prepare() {
        System.out.println("开始准备 "+getName()+":");
        chili = seasoningFactory.createChili();
        douBan = seasoningFactory.createDouBan();
        pepper = seasoningFactory.createPepper();
        salt = seasoningFactory.createSalt();
        System.out.println("以下原料准备完毕:"+chili.sayMyName()
        +","+douBan.sayMyName()+","+pepper.sayMyName()+","+salt.sayMyName());
    }
}

public abstract class PizzaStore {

    public abstract Pizza createPizza(String type);
}

public class StarBoundPizzaStore extends PizzaStore {
    @Override
    public Pizza createPizza(String type) {
        Pizza pizza;
        SeasoningFactory factoryA = new PiXianSeasoningFactory();
        SeasoningFactory factoryB = new GuanXianSeasoningFactory();

        if (type.equals("旧成都披萨")){
            pizza = new ChengduPizza(factoryA);;
        }else if (type.equals("新北京披萨")){
            pizza = new PekingPizza(factoryB);
        }else {
            pizza = new ChengduPizza(factoryB);
        }
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

    public static void main(String[] args) {
        PizzaStore pizzaStore = new StarBoundPizzaStore();
        Pizza pizza = pizzaStore.createPizza("旧成都披萨");
        System.out.println(pizza.toString());
        Pizza pizza1 = pizzaStore.createPizza("新北京披萨");
        System.out.println(pizza1.toString());
    }
}

结果:
开始准备 旧成都披萨:
以下原料准备完毕:虎皮青椒,郫县豆瓣,花椒油,食用盐
烘烤...
切片...
包装...
披萨制作完毕:旧成都披萨
生产原料:虎皮青椒	郫县豆瓣	花椒油	食用盐
开始准备 新北京披萨:
以下原料准备完毕:虎皮青椒,老干妈豆瓣酱,花椒油,食用盐
烘烤...
切片...
包装...
披萨制作完毕:新北京披萨
生产原料:虎皮青椒	老干妈豆瓣酱	花椒油	食用盐