设计模式 工厂模式 从卖肉夹馍说起

今天继续设计模式之旅，给大家带来工厂模式，简单列一下这个模式的家族：

1、静态工厂模式

2、简单工厂模式

3、工厂方法模式

4、抽象工厂模式

是不是觉得，我勒个去，这工厂还能列出这么多分类，哈哈，下面开始各个击破。

1、静态工厂模式

这个最常见了，项目中的辅助类，TextUtil.isEmpty等，类+静态方法。下面开始详细介绍：略。

2、简单工厂模式

下面开始谈谈卖肉夹馍，最近程序员卖肉夹馍很火，啥时候大牛们都去卖了，我等就崛起了，哈哈。

首先你得有个店：RoujiaMoStore

package com.zhy.pattern.factory.a;
 
public class SimpleRouJiaMoFactroy
{
    public RouJiaMo createRouJiaMo(String type)
    {
        RouJiaMo rouJiaMo = null;
        if (type.equals("Suan"))
        {
            rouJiaMo = new SuanRouJiaMo();
 
        } else if (type.equals("Tian"))
        {
            rouJiaMo = new TianRouJiaMo();
        } else if (type.equals("La"))
        {
            rouJiaMo = new LaRouJiaMo();
        }
        return rouJiaMo;
    }
 
}

package com.zhy.pattern.factory.a;
 
public class RoujiaMoStore
{
    private SimpleRouJiaMoFactroy factroy;
 
    public RoujiaMoStore(SimpleRouJiaMoFactroy factroy)
    {
        this.factroy = factroy;
    }
 
    /**
     * 根据传入类型卖不同的肉夹馍
     * 
     * @param type
     * @return
     */
    public RouJiaMo sellRouJiaMo(String type)
    {
        RouJiaMo rouJiaMo = factroy.createRouJiaMo(type);
        rouJiaMo.prepare();
        rouJiaMo.fire();
        rouJiaMo.pack();
        return rouJiaMo;
    }
 
}

3、工厂方法模式

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

好了，看完定义，下面我们用例子来展示。继续肉夹馍，由于使用了简单工厂模式，肉夹馍生意那个好啊，所以下载决定去西安开个分店，去北京开个分店。既然有分店了，那总店就是抽象的了：

package com.zhy.pattern.factory.b;
 
public abstract class RoujiaMoStore
{
 
    public abstract RouJiaMo createRouJiaMo(String type);
 
    /**
     * 根据传入类型卖不同的肉夹馍
     * 
     * @param type
     * @return
     */
    public RouJiaMo sellRouJiaMo(String type)
    {
        RouJiaMo rouJiaMo = createRouJiaMo(type);
        rouJiaMo.prepare();
        rouJiaMo.fire();
        rouJiaMo.pack();
        return rouJiaMo;
    }
 
}

package com.zhy.pattern.factory.b;
 
 
 
/**
 * 西安肉夹馍店
 * 
 * @author zhy
 * 
 */
public class XianRouJiaMoStore extends RoujiaMoStore
{
 
    @Override
    public RouJiaMo createRouJiaMo(String type)
    {
        RouJiaMo rouJiaMo = null;
        if (type.equals("Suan"))
        {
            rouJiaMo = new XianSuanRouJiaMo();
 
        } else if (type.equals("Tian"))
        {
            rouJiaMo = new XianTianRouJiaMo();
        } else if (type.equals("La"))
        {
            rouJiaMo = new XianLaRouJiaMo();
        }
        return rouJiaMo;
 
    }
 
}

1、定义了创建对象的一个接口：public abstract RouJiaMo createRouJiaMo(String type);

2、由子类决定实例化的类，可以看到我们的馍是子类生成的。

可能有人会说，我用简单工厂模式也行啊，但是如果10来个城市*5种风味/城市，那么岂不是简单工厂里面需要50多个if，再说人家西安肉夹馍分店就不能有点自己的秘诀，当然由它自己定最好。

好了，方法工厂模式介绍完毕。

4、抽象工厂模式

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

这定义有点绕口，算了，还是拿例子来说。继续卖肉夹馍，咱们生意这么好，难免有些分店开始动歪脑子，开始使用劣质肉等，砸我们的品牌。所以我们要拿钱在每个城市建立自己的原料场，保证高质量原料的供应。

于是我们新建一个提供原料的接口：

package com.zhy.pattern.factory.b;
 
/**
 * 提供肉夹馍的原料
 * @author zhy
 *
 */
public interface RouJiaMoYLFactroy
{
    /**
     * 生产肉
     * @return
     */
    public Meat createMeat();
    
    /**
     * 生产调料神马的
     * @return
     */
    public YuanLiao createYuanliao();
    
}

package com.zhy.pattern.factory.b;
 
/**
 * 根据西安当地特色，提供这两种材料
 * @author zhy
 *
 */
public class XianRouJiaMoYLFactroy implements RouJiaMoYLFactroy
{
 
    @Override
    public Meat createMeat()
    {
        return new FreshMest();
    }
 
    @Override
    public YuanLiao createYuanliao()
    {
        return new XianTeSeYuanliao();
    }
 
}

package com.zhy.pattern.factory.b;
 
public abstract class RouJiaMo
{
    protected String name;
 
    /**
     * 准备工作
     */
    public final void prepare(RouJiaMoYLFactroy ylFactroy)
    {
        Meat meat = ylFactroy.createMeat();
        YuanLiao yuanliao = ylFactroy.createYuanliao();
        System.out.println("使用官方的原料" + meat + " , " + yuanliao + "作为原材料制作肉夹馍 ");
    }
 
    /**
     * 使用你们的专用袋-包装
     */
    public final void pack()
    {
        System.out.println("肉夹馍-专用袋-包装");
    }
 
    /**
     * 秘制设备-烘烤2分钟
     */
    public final void fire()
    {
        System.out.println("肉夹馍-专用设备-烘烤");
    }
}