设计模式—简单工厂模式

前言

简单工厂模式是一种比较容易理解的设计模式

简单工厂模式介绍

在设计模式中，简单工厂模式可以理解为负责生产对象的一个类，当使用new 关键字创建一个对象时，此时该类就依赖于这个对象，也就是他们间的耦合度高，当需要变换时，需要修改此类的源码。

使用简单工厂的模式解决这一问题---封装改变，既然要封装改变，必然要找份改变的代码然后把改变的代码封装起来

1）实际例子

在外面打工的人，免不了要经常在外面吃饭，当然我们也可以自己在家做饭吃，但是自己做饭吃麻烦，因为又要自己买菜，然而，出去吃饭就完全没有这些麻烦的， 我们只需要到餐馆点菜就可以了，买菜的事情就交给餐馆做就可以了，这里餐馆就充当简单工厂的角色，下面让我们看看现实生活中的例子用代码是怎样来表现的。

自己做饭的情况：

 

 1 /// <summary>
 2     /// 自己做饭的情况
 3     /// 没有简单工厂之前，客户想吃什么菜只能自己炒的
 4     /// </summary>
 5     public class Customer
 6     {
 7         /// <summary>
 8         /// 烧菜方法
 9         /// </summary>
10         /// <param name="type"></param>
11         /// <returns></returns>
12         public static Food Cook(string type)
13         {
14             Food food = null;
15             
16 // 客户A说：我想吃西红柿炒蛋怎么办？
17             
18 // 客户B说：那你就自己烧啊
19             
20 // 客户A说： 好吧，那就自己做吧
21             if (type.Equals("西红柿炒蛋"))
22             {
23                 food = new TomatoScrambledEggs();
24             }
25             
26 // 我又想吃土豆肉丝, 这个还是得自己做
27             
28 // 我觉得自己做好累哦，如果能有人帮我做就好了？
29             else if (type.Equals("土豆肉丝"))
30             {
31                 food = new ShreddedPorkWithPotatoes();
32             }
33             return food;
34         }
35  
36         static void Main(string[] args)
37         {
38             
39 // 做西红柿炒蛋
40             Food food1 = Cook("西红柿炒蛋");
41             food1.Print();
42  
43             Food food2 = Cook("土豆肉丝");
44             food1.Print();
45  
46             Console.Read();
47         }
48     }
49  /// <summary>
50     /// 菜抽象类
51     /// </summary>
52     public abstract class Food
53     {
54         
55 // 输出点了什么菜
56         public abstract void Print();
57     }
58  
59     /// <summary>
60     /// 西红柿炒鸡蛋这道菜
61     /// </summary>
62     public class TomatoScrambledEggs : Food
63     {
64         public override void Print()
65         {
66             Console.WriteLine("一份西红柿炒蛋！");
67         }
68     }
69  
70     /// <summary>
71     /// 土豆肉丝这道菜
72     /// </summary>
73     public class ShreddedPorkWithPotatoes : Food
74     {
75         public override void Print()
76         {
77             Console.WriteLine("一份土豆肉丝");
78         }
79     }

 

自己做饭，如果我们想吃别的菜时，此时就需要去买这种菜和洗菜这些繁琐的操作，有了餐馆（也就是简单工厂）之后，我们就可以把这些操作交给餐馆去做，此时消费者（也就是我们）对菜（也就是具体对象）的依赖关系从直接变成的间接的，这样就是实现了面向对象的另一个原则——降低对象之间的耦合度，（即简单工厂的实现）：

 1 /// <summary>
 2     /// 顾客充当客户端，负责调用简单工厂来生产对象
 3     /// 即客户点菜，厨师（相当于简单工厂）负责烧菜(生产的对象)
 4     /// </summary>
 5     class Customer
 6     {
 7         static void Main(string[] args)
 8         {
 9             
10 // 客户想点一个西红柿炒蛋        
11             Food food1 = FoodSimpleFactory.CreateFood("西红柿炒蛋");
12             food1.Print();
13  
14             
15 // 客户想点一个土豆肉丝
16             Food food2 = FoodSimpleFactory.CreateFood("土豆肉丝");
17             food2.Print();
18  
19             Console.Read();
20         }
21     }
22  
23     /// <summary>
24     /// 菜抽象类
25     /// </summary>
26     public abstract class Food
27     {
28         
29 // 输出点了什么菜
30         public abstract void Print();
31     }
32  
33     /// <summary>
34     /// 西红柿炒鸡蛋这道菜
35     /// </summary>
36     public class TomatoScrambledEggs : Food
37     {
38         public override void Print()
39         {
40             Console.WriteLine("一份西红柿炒蛋！");
41         }
42     }
43  
44     /// <summary>
45     /// 土豆肉丝这道菜
46     /// </summary>
47     public class ShreddedPorkWithPotatoes : Food
48     {
49         public override void Print()
50         {
51             Console.WriteLine("一份土豆肉丝");
52         }
53     }
54  
55     /// <summary>
56     /// 简单工厂类, 负责 炒菜
57     /// </summary>
58     public class FoodSimpleFactory
59     {
60         public static Food CreateFood(string type)
61         {
62             Food food = null;
63             if (type.Equals("土豆肉丝"))
64             {
65                 food= new ShreddedPorkWithPotatoes();
66             }
67             else if (type.Equals("西红柿炒蛋"))
68             {
69                 food= new TomatoScrambledEggs();
70             }
71  
72             return food;
73         }
74     }

 

2）简单工厂模式介绍

简单工厂模式又叫静态方法模式，有一个工厂类根据传入的参数决定创建哪一种产品类的实例

4）简单工厂模式分析

缺点：工厂类集中了所有产品创建逻辑，一旦不能工作，整个系统都受到影响

         扩展困难，一旦要添加新产品就要修改工厂类代码，造成工厂逻辑过于复杂

优点：解决了客户直接依赖于具体产品的问题，客户端可以消除直接创建对象的责任，而仅仅是消费产品。简单工厂模式实现了对责任的分割。

        简单工厂模式也起到了代码复用的作用，因为之前的实现（自己做饭的情况）中，换了一个人同样要去在自己的类中实现做菜的方法，然后有了简单工厂之后，去餐馆吃饭的所有人都不用那么麻烦了，只需要负责消费就可以了

5）简单工厂模式使用场景

  当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式（）

  客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式

转载于:https://www.cnblogs.com/xishuqingchun/p/4970873.html