工厂模式三部曲之二_工厂模式

最新推荐文章于 2023-12-26 16:28:32 发布

Chrysler2015

最新推荐文章于 2023-12-26 16:28:32 发布

阅读量190

点赞数

文章标签：设计模式

原文链接：http://www.cnblogs.com/holyknight-zld/archive/2012/09/06/MethodFactory.html

版权

自《工厂模式三部曲之一_简单工厂模式》之后，貌似已经很久没有继续这个三部曲了，所以抽点时间把后两篇给补上吧。首先回顾下简单工厂模式的主要内容：简单工厂模式就是实质就是专门定义了一个工厂类，利用工厂类的静态方法来根据用户需求创建对象，优点是客户端的压力较小，客户端不需要做创建实例的操作，只需要调用工厂类中的方法就可以获得对应实例，而其缺点也非常明显，其所有创建工作都在一个工厂类完成，耦合性较高，而且当系统需要增加或者修改产品时需要改动工厂类，既不符合单一职责的原则也不符合开放-关闭原则，所以就出现了工厂模式。

工厂模式

工厂模式是对简单工厂模式的进一步抽象化，是简答工厂模式的衍生，根据设计模式的基本原则也是设计模式的精髓“封装变化点”，即哪里发生改变就把哪里封装起来，所以工厂模式对简单工厂中的工厂类做了一个封装，使其满足单一职责和开放-关闭原则。

【解决问题】：简单工厂模式中违背了单一职责和开放-关闭原则。

【核心思想】：建立一个抽象工厂的基类，给每个产品建立一个工厂，该工厂继承之抽象工厂，规定每个产品都有特定的工厂来创建。

【角色】

抽象工厂角色：这是工厂模式的核心，它与应用程序无关，是具体工厂必须继承的父类或者必须实现的接口

具体工厂角色：包含逻辑业务的代码，由应用程序调用以创建对应的具体产品对象

抽象产品角色：具体产品必须继承的父类或者必须实现的接口

具体产品角色：所创建的对象就是此角色的实例

下面仍旧以简单工厂中的实例来讲解，对其进行改造

【角色分析】

抽象工厂：衣服制造厂包含衣服的一些公共特性
具体工厂：**类型衣服制造厂每个衣服制造厂只负责一件衣服(高内聚) ，当然也就是说当没有客户需要的衣服的时候需要创建一个对应的工厂及一件衣服由该工厂负责提供这件衣服但是对于以前的工厂和衣服都没有影响(这是设计模式所期望的--单一职责原则)

抽象产品：衣服包含衣服的一些公共特性
具体产品：**类型衣服继承抽象产品，当然可扩展自身特性

角色分析好了，就可以进行改造了，贴上改造完毕的各个部分代码：

抽象工厂类：

抽象方法

1      // 抽象工厂：声明工厂方法返回一个产品
2      public abstract class ClothFactory
3     {
4         public abstract Cloth CreateCloth();
5     }

该类中定义了一个抽象的CreateCloth()方法，用于创建衣服实例。

具体工厂类：

具体工厂

1      // 具体工厂1：商务装工厂只负责生产商务装
2      public class BusinessFactory : ClothFactory
3     {
4          public override Cloth CreateCloth()
5         {
6              return new BusinessCloth();
7         }
8     }
9
10      // 具体工厂2：运动装工厂只负责生产运动装
11      public class SportFactory : ClothFactory
12     {
13          public override Cloth CreateCloth()
14         {
15              return new SportCloth();
16         }
17     }
18
19      // 具体工厂3：校服工厂只负责生产校服
20      public class LifeFactory : ClothFactory
21     {
22          public override Cloth CreateCloth()
23         {
24              return new LifeCloth();
25         }
26     }

该类为核心，类中定义了BusinessFactory，SportFactory，LifeFactory三个工厂分别来创建商务装，运动装，校服，三个工厂都继承之抽象工厂ClothFactory，并都重写了抽象工厂中的CreateCloth()方法，分别用来创建该工厂生产的衣服，利用里氏替换原则(子类代替父类)来实现，这是产品需要改变(添加,修改,删除)时,如添加，只需要添加一个专门生产该产品的工厂和该产品就可以了，添加操作对之前所有的工厂和产品没有直接的影响。修改同理，只需要修改创建该产品的工厂类就可以了，很好的遵循了开放-关闭原则，同时一个工厂类创建一个产品，遵循了单一职责的原则。

抽象产品类：

抽象产品

1     // 定义抽象产品:衣服
2      public abstract class Cloth
3     {
4         public abstract void GetCloth();
5     }

该方法不需要作改变，仍旧定义了一个GetCloth()方法，模拟使用产品。

具体产品类：

具体产品

1      // 定义具体产:1:商务装
2      class BusinessCloth : Cloth
3     {
4          public override void GetCloth()
5         {
6             Console.WriteLine( " 商务装...... ");
7         }
8     }
9
10      // 定义具体产品2：运动装
11      class SportCloth : Cloth
12     {
13          public override void GetCloth()
14         {
15             Console.WriteLine( " 运动装....... ");
16         }
17     }
18
19      // 定义具体产品3：休闲服
20      class LifeCloth : Cloth
21     {
22          public override void GetCloth()
23         {
24             Console.WriteLine( " 休闲服........ ");
25         }
26     }

该类也不需要作任何改变，根据哪里封装改变哪里，工厂类的封装和产品没有直接的影响，仍旧定义了三种类型的衣服，并重写抽象产品中的抽象方法，因为每种产品都有自身特性，有自身独特的功能。

客户端：

客户端

1      // 客户端
2      class Program
3     {
4          static void Main( string[] args)
5         {
6              // 要求商务装
7             Cloth c = new BusinessFactory().CreateCloth();
8             c.GetCloth();
9
10              // 要求运动装
11             Cloth c2 = new SportFactory().CreateCloth();
12             c2.GetCloth();
13
14             Console.ReadKey();
15         }
16     }

运行效果：