标签：kdump 原理 抽象工厂模式 die span 韭菜 flavor fresh 开心
最近在啃设计模式，这篇文章是设计模式的第一篇，希望可以一直写下去。
工厂模式和抽象工厂模式都属于创建型模式，是用来创建对象的。程序中将创建对象的操作（例如各种new）抽离到单独的接口中，由接口的子类来完成对象的创建工作，从而实现对象的创建与业务逻辑解耦的目的。这里所说的接口，既包括interface，也包括抽象类。
下面以“饺子”作为例子来讲解这两种模式的用法，饺子是我们要生产的产品，而工厂是我们生产饺子的工具。饺子馅儿的口味有很多，这里只举出三种：韭菜、鲜肉、萝卜。
工厂模式的做法是，每个产品对应一个工厂，由工厂来负责对应产品的创建工作，工厂模式将生成产品的任务交给具体的子类来完成，做到了与具体产品类的解耦。
首先定义一个产品接口：
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 }
抽象工厂模式的职责是创建一个产品簇，这往往意味着创建许多不同类型的产品，而工厂模式只负责创建单一产品。
对于饺子来说，除了馅儿之外，一般还会放一些配料，例如：葱、姜、蒜等，那么此时我们就需要一个配料工厂专门生产这些配料了。这些配料属于不同的产品系，它们合在一起构成饺子的配料，我们把类似配料的这样的一系列产品称为产品簇，显然，工厂模式无法完成这个生产任务，这里就需要用到抽象工厂模式了。实际上，抽象工厂在生成每一类产品时，使用的还是工厂模式的原理。
首先，是定义配料接口以及具体的配料子类。
配料接口：
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 }
一般提到工厂模式的时候，都会提到简单工厂，简单工厂是把所有产品的创建任务放在一个类里面完成，一旦有新的产品，就需要修改简单工厂里面的生产逻辑。
关于饺子，一个简单工厂可能类似于：
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 }
简单工厂是一个具体类，负责生产所有的产品，当有新的产品产生时，就需要修改生产产品的逻辑，不符合“对扩展开放，对修改关闭”的原则；工厂模式会为每个产品生成一个对应的工厂，当有新的产品出现时，只需要增加新的工厂即可；抽象工厂能够生成一个产品簇，其中的每一个生产产品的方法都是利用了工厂模式。
标签：kdump 原理 抽象工厂模式 die span 韭菜 flavor fresh 开心
原文地址：https://www.cnblogs.com/NaLanZiYi-LinEr/p/11487872.html
