设计模式——（Abstract Factory）抽象工厂“改正为简单工厂”

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

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

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

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

　　结构：

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

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

    public abstract class Vehicle
     {
         private string name;
         //品牌
         public string Name
         {
             get { return name; }
             set { name = value; }
         }
         private string color;
         //颜色
         public string Color
         {
             get { return color; }
             set { color = value; }
         }
         public Vehicle()
         { }
         public Vehicle(string name, string color)
         {
             this.Name = name;
             this.Color = color;
         }
         public virtual int Price()
         {
             int price = ;

             return price;
         }

定义轿车类Car继承Vehicle

   public class Car : Vehicle
     {
         private int seat;
         //座位数
         public int Seat
         {
             get { return seat; }
             set { seat = value; }
         }
         public Car()
         { }
         public Car(string name, string color, int seat) :
             base(name, color)
         {
             this.Seat = seat;
         }
         public override int Price()
         {
             int price = ;
             price =  * Seat;
             return price;
         }
     }

定义卡车类Truck继承Vehicle

        private int load;
         //载重量
         public int Load
         {
             get { return load; }
             set { load = value; }
         }
         public Truck()
         { }
         public Truck(string name, string color, int load)
             : base(name, color)
         {
             this.Load = load;
         }
         public override int Price()
         {
             int price = ;
             price =  * Load;
             return price;
         }

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

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

     /// <summary>
     /// 工厂类
     /// </summary>
     public class VehicleFactory
     {
         public static Vehicle CreateVehicle(string name, string color, int seat, int load,string type)
         {
             Vehicle vehicle = null;
             switch (type)
             {
                 case "car":
                     vehicle = new Car(name, color, seat);
                     break;
                 case "truck":
                     vehicle = new Truck(name, color, load);
                     break;
             }
             return vehicle;
         }

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

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

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

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

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

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

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

　　QQ:2584451009