设计模式——（Abstract Factory）抽象工厂

设计面向对象软件比较困难，而设计可复用的面向对象软件就更加困难。你必须设计相关类，并设计类的接口和继承之间的关系。设计必须可以解决当前问题，同时必须对将来可能发生的问题和需求也有足够的针对性。掌握面向对象的设计模式，可以比较轻松的解决上述问题。
本篇文章主要讲解设计模式中最基本，也是最常用的（Abstract Factory）抽象工厂。
适用性：
在以下情况可以使用Abstract Factory模式
• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。
举个例子讲解一下Abstract Factory主要应用场景。我们试想一下一辆轿车的制造过程，在最初学习面向对象编程时，我们会定义一个轿车类，里面封装了轿车的一系列属性，并且由轿车类自己将自己初始化。显然这样做足以应付当前需求，但是在将来的某一天我们需要设计一辆卡车呢？我们是不是必须再定义一个卡车类呢？这显然不符合可复用的软件设计思想。在面向对象的软件设计模式中，我们充分分析轿车和卡车的属性，抽象出一个公共的父类，并由轿车和卡车继承，再定义一个Factory类来实例化轿车和卡车。采用这样的设计模式，将来在增加自行车，摩托车等等只需定义它们的属性即可，它们的初始化过程不需要重新定义。
结构：



下面我对上面问题进行一下具体讲解：
首先我们定义公共父类Vehicle：应为Vehicle 不需要实例化所以定义为抽象类。

1    public abstract class Vehicle
 2     {
 3         private string name;
 4         //品牌
 5         public string Name
 6         {
 7             get { return name; }
 8             set { name = value; }
 9         }
10         private string color;
11         //颜色
12         public string Color
13         {
14             get { return color; }
15             set { color = value; }
16         }
17         public Vehicle()
18         { }
19         public Vehicle(string name, string color)
20         {
21             this.Name = name;
22             this.Color = color;
23         }
24         public virtual int Price()
25         {
26             int price = 0;
27 
28             return price;
29         }

View Code 定义轿车类Car继承Vehicle

1   public class Car : Vehicle
 2     {
 3         private int seat;
 4         //座位数
 5         public int Seat
 6         {
 7             get { return seat; }
 8             set { seat = value; }
 9         }
10         public Car()
11         { }
12         public Car(string name, string color, int seat) :
13             base(name, color)
14         {
15             this.Seat = seat;
16         }
17         public override int Price()
18         {
19             int price = 0;
20             price = 4 * Seat;
21             return price;
22         }
23     }

View Code 定义卡车类Truck继承Vehicle

1        private int load;
 2         //载重量
 3         public int Load
 4         {
 5             get { return load; }
 6             set { load = value; }
 7         }
 8         public Truck()
 9         { }
10         public Truck(string name, string color, int load)
11             : base(name, color)
12         {
13             this.Load = load;
14         }
15         public override int Price()
16         {
17             int price = 0;
18             price = 4 * Load;
19             return price;
20         }

View Code 它们之间的继承关系如下：



定义VehicleFactory类 初始化 轿车或卡车对象：

1     /// <summary>
 2     /// 工厂类
 3     /// </summary>
 4     public class VehicleFactory
 5     {
 6         public static Vehicle CreateVehicle(string name, string color, int seat, int load,string type)
 7         {
 8             Vehicle vehicle = null;
 9             switch (type)
10             { 
11                 case "car":
12                     vehicle = new Car(name, color, seat);
13                     break;
14                 case "truck":
15                     vehicle = new Truck(name, color, load);
16                     break;
17             }
18             return vehicle;
19         }

View Code Abstract Factory模式有下面的一些优点和缺点：
1) 它分离了具体的类：
Abstract Factory模式帮助你控制一个应用创建的对象的类。
2) 它使得易于交换产品系列
一个具体工厂类在一个应用中仅出现一次—即在它初始化的时候。
3) 它有利于产品的一致性
当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而Abstract Factory很容易实现这一点。
4) 难以支持新种类的产品
难以扩展抽象工厂以生产新种类的产品。
经过上面的讲解不知道大家对（Abstract Factroy）抽象工厂的模式设计是否有所了解呢？如果有什么地方看不懂的话可以与我联系。
~蒋继发
QQ:2584451009