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

设计面向对象软件比较困难，而设计可复用的面向对象软件就更加困难。你必须设计相关类，并设计类的接口和继承之间的关系。设计必须可以解决当前问题，同时必须对将来可能发生的问题和需求也有足够的针对性。掌握面向对象的设计模式，可以比较轻松的解决上述问题。

本篇文章主要讲解设计模式中最基本，也是最常用的（Abstract Factory）抽象工厂。

适用性：
在以下情况可以使用Abstract Factory模式
• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

举个例子讲解一下Abstract Factory主要应用场景。我们试想一下一辆轿车的制造过程，在最初学习面向对象编程时，我们会定义一个轿车类，里面封装了轿车的一系列属性，并且由轿车类自己将自己初始化。显然这样做足以应付当前需求，但是在将来的某一天我们需要设计一辆卡车呢？我们是不是必须再定义一个卡车类呢？这显然不符合可复用的软件设计思想。在面向对象的软件设计模式中，我们充分分析轿车和卡车的属性，抽象出一个公共的父类，并由轿车和卡车继承，再定义一个Factory类来实例化轿车和卡车。采用这样的设计模式，将来在增加自行车，摩托车等等只需定义它们的属性即可，它们的初始化过程不需要重新定义。

结构：

下面我对上面问题进行一下具体讲解：

首先我们定义公共父类Vehicle：应为Vehicle 不需要实例化所以定义为抽象类。

   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 Color13         {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         }

定义轿车类Car继承Vehicle

  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     }

定义卡车类Truck继承Vehicle

       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         }

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

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

    /// <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         }

Abstract Factory模式有下面的一些优点和缺点：
1) 它分离了具体的类：

Abstract Factory模式帮助你控制一个应用创建的对象的类。

2) 它使得易于交换产品系列

一个具体工厂类在一个应用中仅出现一次—即在它初始化的时候。
3) 它有利于产品的一致性

当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而Abstract Factory很容易实现这一点。
4) 难以支持新种类的产品

难以扩展抽象工厂以生产新种类的产品。

经过上面的讲解不知道大家对（Abstract Factroy）抽象工厂的模式设计是否有所了解呢？如果有什么地方看不懂的话可以与我联系。

~蒋继发

QQ:2584451009