设计模式1-简单工厂模式与工厂方法模式

Posted 2020-07-06

简单工厂模式：建立一个工厂类，由调用方传递参数给工厂类判断返回具体的实例。

先来上类图，PS：平常做代码搬运工的日子里，不需要画图，也不会画更不会画，所以从0开始学画，目的为加深理解。

 1 namespace DesignModel.简单工厂模式
 2 {
 3 
 4 
 5     public class AnimalFactory
 6     {
 7         internal static Animal GetAnimal(string name)
 8         {
 9             Animal animal = null;
10             switch (name)
11             {
12                 case "牛":
13                     animal = new A();
14                     break;
15                 case "鸡":
16                     animal = new B();
17                     break;
18                 default:
19                     animal = new C();
20                     break;
21             }
22             return animal;
23         }
24     }
25 
26     abstract class Animal
27     {
28         public int Weigtht { get; set; }
29         public string Name { get; set; }
30         public abstract void laugh();
31     }
32     internal class A : Animal
33     {
34         public override void laugh() { }
35     }
36     internal class B : Animal
37     {
38         public override void laugh() { }
39     }
40     internal class C : Animal
41     {
42         public override void laugh() { }
43     }
44 }
45 
46         /// <summary>
47         /// 使用
48         /// </summary>
49         static void 简单工厂模式()
50         {
51             var animal= AnimalFactory.GetAnimal("A");
52             animal.laugh();
53 
54         }

View Code

 

优点：工厂类中包含逻辑判断，根据调用方选择去实例化相关的类。对于调用方来说，去除了与具体产品的依赖。

缺点：如果需要增加产品类，需要修改工厂类添加CASE分支。违背了开闭原则。

 

工厂方法模式：定义创建对象的接口，让接口的子类决定实例化具体类，把一个类的实例化延迟到其子类。

 1 namespace DesignModel.工厂方法模式
 2 {
 3     internal interface IFactory
 4     {
 5         Animal CreateAnimal();
 6     }
 7 
 8 
 9     class AFactory : IFactory
10     {
11         public Animal CreateAnimal()
12         {
13             return new A();
14         }
15     }
16      class BFactory : IFactory
17     {
18         public Animal CreateAnimal()
19         {
20             return new B();
21         }
22     }
23 
24     abstract class Animal
25     {
26         public int Weigtht { get; set; }
27         public string Name { get; set; }
28         public abstract void laugh();
29     }
30 
31     class A : Animal
32     {
33         public override void laugh() { }
34     }
35     class B : Animal
36     {
37         public override void laugh() { }
38     }
39 
40 }
41 static void 工厂方法模式()
42      {
43           IFactory If = new AFactory();
44           var ani= If.CreateAnimal();
45           ani.laugh();
46      }

View Code

 

以上两个模式中工厂类均返回具体产品的父类，针对抽象编程。

 

 附上设计原则：

1 开闭原则（对扩展开放，对修改关闭）

2 单一职责原则（不要存在多于一个导致类变更的原因，一个类只负责一项职责）

3 依赖倒转原则（高层模块不应依赖低层模块，都应依赖抽象，针对接口编程）

4 里氏替换原则（子类能够代替父类，也就是父子无依赖，只依赖接口）

5 接口隔离原则（最小化接口，子类只依赖需要的接口）

6 迪米特法则（对象之间松藕合，一个对象应该对其它对象最少关联，如要调用其它对象方法，可以通过第三者转发这个调用）