工厂模式和抽象工厂模式

      最近在啃设计模式，这篇文章是设计模式的第一篇，希望可以一直写下去。

      工厂模式和抽象工厂模式都属于创建型模式，是用来创建对象的。程序中将创建对象的操作（例如各种new）抽离到单独的接口中，由接口的子类来完成对象的创建工作，从而实现对象的创建与业务逻辑解耦的目的。这里所说的接口，既包括interface，也包括抽象类。

      下面以“饺子”作为例子来讲解这两种模式的用法，饺子是我们要生产的产品，而工厂是我们生产饺子的工具。饺子馅儿的口味有很多，这里只举出三种：韭菜、鲜肉、萝卜。

1. 工厂模式

      工厂模式的做法是，每个产品对应一个工厂，由工厂来负责对应产品的创建工作，工厂模式将生成产品的任务交给具体的子类来完成，做到了与具体产品类的解耦。

      首先定义一个产品接口：

public interface Dumpling{
    String getFlavor();  //获取饺子口味    
}

      接下来是三个具体口味的饺子：

public class FreshmeatDumpling implements Dumpling{
    String flavor = "鲜肉馅儿饺子";

    @Override
    public String getFlavor(){
        return flavor;
    }
}

public class LeekDumpling implements Dumpling{
    String flavor = "韭菜馅儿饺子";

    @Override
    public String getFlavor(){
        return flavor;
    }
}

public class RadishDumpling implements Dumpling{
    String flavor = "萝卜馅儿饺子";

    @Override
    public String getFlavor(){
        return flavor;
    }
}

      产品定义好之后，需要定义工厂来生产这些产品，也就是饺子。

      先定义工厂接口：

public interface DumplingFactory{
    Dumpling createDumpling();  //生产饺子
}

      接下来为每一种饺子定义一个对应的工厂：

public class FreshmeatDumplingFactory implements DumplingFactory{
    public Dumpling createDumpling(){
        return new FreshmeatDumpling();  //来一份鲜肉馅儿饺子
    }
}

public class LeekDumplingFactory implements DumplingFactory{
    public Dumpling createDumpling(){
        return new LeekDumpling();  //来一份韭菜馅儿饺子
    }
}

public class RedishRDumplingFactory implements DumplingFactory{
    public Dumpling createDumpling(){
        return new RedishDumpling();  //来一份萝卜馅儿饺子
    }
}

      好了，所有的准备工作都做完了，现在就可以开心的点餐了^_^。

public static void main(String[] args){
    DumplingFactory factory = new LeekDumpingFactory();
    Dumpling dumpling = factory.createDumpling();
    System.out.println(dumpling.getFlavor());  //韭菜馅儿饺子

    factory = new RedishDumplingFactory();
    dumpling = factory.createDumpling();
    System.out.println(dumpling.getFlavor());  //萝卜馅儿饺子
}

2. 抽象工厂模式

      抽象工厂模式的职责是创建一个产品簇，这往往意味着创建许多不同类型的产品，而工厂模式只负责创建单一产品。

      对于饺子来说，除了馅儿之外，一般还会放一些配料，例如：葱、姜、蒜等，那么此时我们就需要一个配料工厂专门生产这些配料了。这些配料属于不同的产品系，它们合在一起构成饺子的配料，我们把类似配料的这样的一系列产品称为产品簇，显然，工厂模式无法完成这个生产任务，这里就需要用到抽象工厂模式了。实际上，抽象工厂在生成每一类产品时，使用的还是工厂模式的原理。

      首先，是定义配料接口以及具体的配料子类。

      配料接口：

 1 // 葱
 2 public interface Scallion{
 3     String getName();  
 4 }
 5 
 6 // 姜
 7 public interface Ginger{
 8     String getName();  
 9 }
10 
11 // 蒜
12 public interface Garlic{
13     String getName();  
14 }

      具体配料：

public class GreenChineseonion implements Scallion{
    private String name = "大葱";
    public String getName(){
        return name;
    }
}

public class Shallot implements Scallion{
    private String name = "小葱";
    public String getName(){
        return name;
    }
}

public class RedGinger implements Ginger{
    private String name = "紫姜";
    public String getName(){
        return name;
    }
}

public class YellowGinger implements Ginger{
    private String name = "黄姜";
    public String getName(){
        return name;
    }
}

public class WhiteGarlic implements Garlic{
    private String name = "白皮蒜";
    public String getName(){
        return name;
    }
}

public class PurpleGarlic implements Garlic{
    private String name = "紫皮蒜";
    public String getName(){
        return name;
    }
}

      接下来定义生产配料的工厂：

public interface IngredientsFactory{
    Scallion createScallion();  //生产葱
    Ginger createGinger();      //生产姜
    Garlic createGarlic();        //生产蒜
}

      然后定义具体配料工厂：

// 鲜肉馅儿饺子配料
public class FreshMeatDumplingIngredientsFactory implements IngredientsFactory{
    public Scallion createScallion(){
        return new Shallot();
    }

    public Ginger createGinger(){
        return new RedGinger();
    }

    public Garlic createGarlic(){
        return new WhiteGarlic();
    }
}

// 韭菜馅儿饺子配料
public class LeekDumplingIngredientsFactory implements IngredientsFactory{
    public Scallion createScallion(){
        return new Shallot();
    }

    public Ginger createGinger(){
        return new RedGinger();
    }

    public Garlic createGarlic(){
        return new PurpleGarlic();
    }
}

// 萝卜馅儿饺子配料
public class RadishDumplingIngredientsFactory implements IngredientsFactory{
    public Scallion createScallion(){
        return new GreenChineseonion();
    }

    public Ginger createGinger(){
        return new YellowGinger();
    }

    public Garlic createGarlic(){
        return new Garlic
    }
}

      然后，就可以来点配料尝尝咸淡了。

public static void main(String[] args){
    IngredientsFactory ingredientsFactory = new RadishDumplingIngredientsFactory();
    System.out.println(ingredientsFactory.createScallion().getName);
    System.out.println(ingredientsFactory.createGinger().getName);
    System.out.println(ingredientsFactory.createGarlic().getName);
}

3. 简单工厂

      一般提到工厂模式的时候，都会提到简单工厂，简单工厂是把所有产品的创建任务放在一个类里面完成，一旦有新的产品，就需要修改简单工厂里面的生产逻辑。

      关于饺子，一个简单工厂可能类似于：

public class SimpleDumplingFactory{
    public Dumpling createDumpling(String type){
        switch(type){
            case "freshMeat":
              return new FreshMeatDumpling();
              break;
            case "leek":
              return new LeekDumpling();
              break;
            case "radish":
              return new RadishDumpling();
              break;
            default:
              return new FreshMeatDumpling();
              break;
        } 
     }
}        

4. 总结

      简单工厂是一个具体类，负责生产所有的产品，当有新的产品产生时，就需要修改生产产品的逻辑，不符合“对扩展开放，对修改关闭”的原则；工厂模式会为每个产品生成一个对应的工厂，当有新的产品出现时，只需要增加新的工厂即可；抽象工厂能够生成一个产品簇，其中的每一个生产产品的方法都是利用了工厂模式。

 5. 参考

<<Head First设计模式>>