一、前言

　　同样在上班的路上，一个程序员想着是买梅干菜肉包还是买酸辣粉丝包，到了包子点 却发现只有馒头馅子的包子了，却买了一包豆浆；一个程序员可能在在家吃完饭开车 去上班了，这尼玛是富二代；一个程序员可能想着如何把自己的代码如何优化，如何 提高性能，如何的如何……上班路上的程序员让你轻松了解三个设计模式。

　　二、简单工厂模式

　　简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Met hod)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同 类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通 常都具有共同的父类。简单工厂模式就好比一个是一个富二代程序员，你要什么，简 单工厂就给你什么。简单工厂模式包括三个角色：抽象产品角色，具体产品角色，工 厂角色代码实现如下： 

C#代码
  1. //抽象产品角色：交通工具车    
  2. public abstract class Car    
  3. {  
  4.     public virtual void GoToWork()    
  5.     {    
  6.     }    
  7. }
  8. //具体产品角色：自行车    
  9. public class Bike : Car    
  10. {          
  11.     public override void GoToWork()    
  12.     {    
  13.         Console.WriteLine("骑自行车去上班");    
  14.     }    
  15. }    
  16. //具体产品角色：公交车    
  17. public class Bus : Car    
  18. {  
  19.     public override void GoToWork()    
  20.     {    
  21.         Console.WriteLine("做公交车去上班");    
  22.     }    
  23. }    
  24. //工厂角色：简单工厂类    
  25. public class SimpleFactory    
  26. {  
  27.     public static Car CreateSimple(string str)    
  28.     {    
  29.         Car simple = null;  
  30.         switch (str)    
  31.         {  
  32.             case "Bike":    
  33.                 simple = new Bike();  
  34.                 break;  
  35.             case "Bus":    
  36.                 simple = new Bus();  
  37.                 break;  
  38.             //……   
  39.         }  
  40.         return simple;      
  41.     }    
  42. }    

　　客户端调用代码：

C#代码
  1. //根据客户端传入的参数简单工厂决定如何去上班  
  2. Car car = SimpleFactory.CreateSimple("Bus");  
  3. car.GoToWork();  

　　三、工厂方法模式

　　工厂方法模式(Factory Method Pattern)又称为工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式 。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负 责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完 成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。工厂方法模式包括四 个角色：抽象产品角色，具体产品角色，抽象工厂角色，具体工厂角色具体示例代码 实现如下：

C#代码
  1. //抽象产品角色：交通工具车  
  2. public abstract class Car  
  3. {
  4.     public virtual void GoToWork()  
  5.     {  
  6.     }    
  7. }
  8. //具体产品角色：自行车  
  9. public class Bike : Car  
  10. {
  11.     public override void GoToWork()  
  12.     {  
  13.         Console.WriteLine("骑自行车去上班");  
  14.     }  
  15. }
  16. //具体产品角色：公交车  
  17. public class Bus : Car  
  18. {
  19.     public override void GoToWork()  
  20.     {  
  21.         Console.WriteLine("做公交车去上班");  
  22.     }  
  23. }
  24. //抽象工厂角色：工厂接口  
  25. public interface IFactory  
  26. {  
  27.     Car ByWhatWay();  
  28. }
  29. //具体工厂类：自行车类  
  30. public class BikeFactory : IFactory  
  31. {
  32.     public Car ByWhatWay()  
  33.     {
  34.          return new Bike();  
  35.     }  
  36. }
  37. //具体工厂类：公交车类  
  38. public class BusFactory : IFactory  
  39. {
  40.     public Car ByWhatWay()  
  41.     {
  42.          return new Bus();  
  43.     }    
  44. }  

　　客户端调用代码：

C#代码
  1. //根据客户端实例化的工厂决定如何去上班  
  2. IFactory factory = new BusFactory();   
  3. //常规写法            
  4. //反射优化  (BusFactory)Assembly.Load("当前程序集名称").CreateInstance("当前命名空间名称.要实例化的类名")            
  5. //using System.Reflection; 引用命名空间            
  6. //var factoryName = "BusFactory";            
  7. //IFactory factory = (BusFactory) Assembly.Load("当前程序集名称").CreateInstance("当前命名空间名称." + factoryName);              
  8. Car car = factory.ByWhatWay();  
  9. car.GoToWork();  

　　四、抽象工厂模式

　　抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对 象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型 模式。抽象工厂模式包括四个角色：抽象产品角色，具体产品角色，抽象工厂角色， 具体工厂角色具体示例代码如下：

C#代码
  1. //抽象交通工具车  
  2. public abstract class Car  
  3. {        
  4.     //名字  
  5.     public string CarName{ get; set; }
  6.     public virtual string GoToWork()  
  7.     {
  8.         return CarName;  
  9.     }   
  10. }    
  11. //抽象早饭类  
  12. public abstract class BreakFast  
  13. {
  14.     //早饭名称  
  15.     public string FoodName { get; set; }
  16.     public virtual string Eat()  
  17.     {
  18.         return FoodName;  
  19.     }  
  20. }
  21. //自行车  
  22. public class Bike : Car  
  23. {
  24.     public override string GoToWork()  
  25.     {  
  26.         CarName = "骑着自行车";            
  27.         return CarName;  
  28.     }  
  29. }    
  30. //公交车  
  31. public class Suv: Car  
  32. {
  33.     public override string GoToWork()  
  34.     {  
  35.         CarName = "开着SUV汽车";
  36.         return CarName;  
  37.     }  
  38. }    
  39. //高逼格早饭：三明治牛奶  
  40. public class SandWichAndMilk : BreakFast  
  41. {
  42.     public override string Eat()  
  43.     {  
  44.         FoodName = "三明治和牛奶";
  45.         return FoodName;  
  46.     }  
  47. }      
  48. //苦逼早饭：包子豆浆  
  49. public class BaoziAndDoujiang : BreakFast  
  50. {
  51.     public override string Eat()  
  52.     {  
  53.         FoodName = "包子豆浆";
  54.         return FoodName;  
  55.     }  
  56. }    
  57. //抽象工厂类  
  58. public abstract class AbstractFactory  
  59. {        
  60.     //创建交通工具方法  
  61.     public abstract Car CreatCar();        
  62.     //创建早饭方法  
  63.     public abstract BreakFast CreateBreakFast();  
  64.   
  65. }    
  66. //具体工厂类：苦逼程序员  
  67. public class LowFactory : AbstractFactory  
  68. {
  69.     public override Car CreatCar()  
  70.     {
  71.         return new Bike();  
  72.     }
  73.     public override BreakFast CreateBreakFast()  
  74.     {
  75.         return new BaoziAndDoujiang();  
  76.     }  
  77. }    
  78. //具体工厂类：高逼格程序员  
  79. public class HighFactory : AbstractFactory  
  80. {
  81.     public override Car CreatCar()  
  82.     {
  83.         return new Suv();  
  84.     }
  85.     public override BreakFast CreateBreakFast()  
  86.     {
  87.         return new SandWichAndMilk();  
  88.     }  
  89. }
  90. public class CoderLove  
  91. {
  92.     private Car car;
  93.     private BreakFast breakFast;
  94.     public CoderLove (AbstractFactory fac)  
  95.     {  
  96.         car=fac.CreatCar();  
  97.         breakFast=fac.CreateBreakFast();  
  98.     }
  99.     public void GetCoderLove()  
  100.     {  
  101.         Console.WriteLine("早饭吃完"+breakFast.Eat()+","+car.GoToWork()+"去上班");  
  102.     }  
  103. }  

　　客户端调用：

C#代码
  1. AbstractFactory factory=new HighFactory();  
  2. CoderLove coder=new CoderLove(factory);  
  3. coder.GetCoderLove();  

　　抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔 离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工 厂中定 义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变 整 个软件系统的行为。除了以上苦逼程序员，高逼格程序员，还可以具体添加一个开 车SUV吃着包子豆浆的具体工厂，也可以添加骑着自行车吃着三明治牛奶的具体工厂 。

　　五、总结

　　1、这个三个模式都属于对象创建型模式

　　2、简单工厂模式简单的理解为客户端告诉工厂他想要什么实例，工厂就给生产什么实 例

　　3、工厂方法模式可以理解客户端有了创建实例的机器，他想要什么实例就自己生产什 么实例

　　4、抽象工厂模式最常见的情况是一套程序需要多套数据实现的情况下

　　示例代码下载：https://yunpan.cn/cY8cctUs7pXSb （提取码：157b）

除非特别注明，鸡啄米文章均为原创
转载请标明本文地址：http://www.jizhuomi.com/software/539.html
2016年4月1日
作者:鸡啄米 分类:软件开发 浏览: 评论:0