码迷,mamicode.com
首页 > 其他好文 > 详细

工厂模式和抽象工厂模式

时间:2019-09-08 20:04:18      阅读:87      评论:0      收藏:0      [点我收藏+]

标签:kdump   原理   抽象工厂模式   die   span   韭菜   flavor   fresh   开心   

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

      工厂模式和抽象工厂模式都属于创建型模式,是用来创建对象的。程序中将创建对象的操作(例如各种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. 总结

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

 

工厂模式和抽象工厂模式

标签:kdump   原理   抽象工厂模式   die   span   韭菜   flavor   fresh   开心   

原文地址:https://www.cnblogs.com/NaLanZiYi-LinEr/p/11487872.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!