工厂模式和抽象工厂模式

Posted 2022-10-09 nalanziyi-liner

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

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

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

1. 工厂模式

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

      首先定义一个产品接口：

1 public interface Dumpling
2     String getFlavor();  //获取饺子口味    
3 

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

 1 public class FreshmeatDumpling implements Dumpling
 2     String flavor = "鲜肉馅儿饺子";
 3 
 4     @Override
 5     public String getFlavor()
 6         return flavor;
 7     
 8 
 9 
10 public class LeekDumpling implements Dumpling
11     String flavor = "韭菜馅儿饺子";
12 
13     @Override
14     public String getFlavor()
15         return flavor;
16     
17 
18 
19 public class RadishDumpling implements Dumpling
20     String flavor = "萝卜馅儿饺子";
21 
22     @Override
23     public String getFlavor()
24         return flavor;
25     
26 

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

      先定义工厂接口：

1 public interface DumplingFactory
2     Dumpling createDumpling();  //生产饺子
3 

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

 1 public class FreshmeatDumplingFactory implements DumplingFactory
 2     public Dumpling createDumpling()
 3         return new FreshmeatDumpling();  //来一份鲜肉馅儿饺子
 4     
 5 
 6 
 7 public class LeekDumplingFactory implements DumplingFactory
 8     public Dumpling createDumpling()
 9         return new LeekDumpling();  //来一份韭菜馅儿饺子
10     
11 
12 
13 public class RedishRDumplingFactory implements DumplingFactory
14     public Dumpling createDumpling()
15         return new RedishDumpling();  //来一份萝卜馅儿饺子
16     
17 

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

1 public static void main(String[] args)
2     DumplingFactory factory = new LeekDumpingFactory();
3     Dumpling dumpling = factory.createDumpling();
4     System.out.println(dumpling.getFlavor());  //韭菜馅儿饺子
5 
6     factory = new RedishDumplingFactory();
7     dumpling = factory.createDumpling();
8     System.out.println(dumpling.getFlavor());  //萝卜馅儿饺子
9 

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 

      具体配料：

 1 public class GreenChineseonion implements Scallion
 2     private String name = "大葱";
 3     public String getName()
 4         return name;
 5     
 6 
 7 
 8 public class Shallot implements Scallion
 9     private String name = "小葱";
10     public String getName()
11         return name;
12     
13 
14 
15 public class RedGinger implements Ginger
16     private String name = "紫姜";
17     public String getName()
18         return name;
19     
20 
21 
22 public class YellowGinger implements Ginger
23     private String name = "黄姜";
24     public String getName()
25         return name;
26     
27 
28 
29 public class WhiteGarlic implements Garlic
30     private String name = "白皮蒜";
31     public String getName()
32         return name;
33     
34 
35 
36 public class PurpleGarlic implements Garlic
37     private String name = "紫皮蒜";
38     public String getName()
39         return name;
40     
41 

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

1 public interface IngredientsFactory
2     Scallion createScallion();  //生产葱
3     Ginger createGinger();      //生产姜
4     Garlic createGarlic();        //生产蒜
5 

      然后定义具体配料工厂：

 1 // 鲜肉馅儿饺子配料
 2 public class FreshMeatDumplingIngredientsFactory implements IngredientsFactory
 3     public Scallion createScallion()
 4         return new Shallot();
 5     
 6 
 7     public Ginger createGinger()
 8         return new RedGinger();
 9     
10 
11     public Garlic createGarlic()
12         return new WhiteGarlic();
13     
14 
15 
16 // 韭菜馅儿饺子配料
17 public class LeekDumplingIngredientsFactory implements IngredientsFactory
18     public Scallion createScallion()
19         return new Shallot();
20     
21 
22     public Ginger createGinger()
23         return new RedGinger();
24     
25 
26     public Garlic createGarlic()
27         return new PurpleGarlic();
28     
29 
30 
31 // 萝卜馅儿饺子配料
32 public class RadishDumplingIngredientsFactory implements IngredientsFactory
33     public Scallion createScallion()
34         return new GreenChineseonion();
35     
36 
37     public Ginger createGinger()
38         return new YellowGinger();
39     
40 
41     public Garlic createGarlic()
42         return new Garlic
43     
44 

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

1 public static void main(String[] args)
2     IngredientsFactory ingredientsFactory = new RadishDumplingIngredientsFactory();
3     System.out.println(ingredientsFactory.createScallion().getName);
4     System.out.println(ingredientsFactory.createGinger().getName);
5     System.out.println(ingredientsFactory.createGarlic().getName);
6 

3. 简单工厂

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

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

 1 public class SimpleDumplingFactory
 2     public Dumpling createDumpling(String type)
 3         switch(type)
 4             case "freshMeat":
 5               return new FreshMeatDumpling();
 6               break;
 7             case "leek":
 8               return new LeekDumpling();
 9               break;
10             case "radish":
11               return new RadishDumpling();
12               break;
13             default:
14               return new FreshMeatDumpling();
15               break;
16          
17      
18         

4. 总结

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