简单工厂模式和抽象工厂模式的通俗理解

 

以造汽车为例来通俗的说一下：（写的不好或有错误的地方欢迎大家指正）

汽车制造商要造汽车卖给客户，那应该如可来做？看下面：

 

    第一：汽车制造商要知道客户要什么样的汽车，即设计汽车；

   第二：设计完后，一切ok后，就可以制造汽车了；

 

  根据上面二步描述，我们用程序表达出来就是（假设现在要造一辆Buick）：

 

    a . 设计师和工程师去设计汽车；

  public   class  BuickCar   //设计buick车
  ... {
     ……
   public string Dec()
        ...{
                return "Buick";
         }
 }

BuickCar buick  =   new  BuickCar();   // 造了辆buick

     
      结构就是

 

上面的很好理解，我们继续：
    
    假设现在要造一辆Benze，那做法和上面一样设计汽车 制造汽车。即：

public   class  BenzeCar     // 设计汽车
... {
   //……
  public string Dec()
   ...{
     return "Benze";
   }
 }

BenzeCar benze =   new  BenzeCar();       //  制造一辆benze汽车

                            

    注：从上面的例子可以发现，制造商每次要一辆新车，都要重新设计一下（重复劳动）。而制造商设计的每一种汽车，它们之间存在一些共同的特新（比如都是流线性 什么的，本人不太懂汽车）。既然有了这些共性，那么把问题高度抽象化来考虑就是，制造商不知道以后需要设计什么样的汽车，也不知道以后的汽车会有什么新的特性。但是只要是汽车，都可能会有共同的特性。那么就可以提高效率。用程序表达出来就是：

       1. 建一个汽车的抽象类：

public   abstract   class  Car
... {
 // ……
 public abstract string Dec(); // 汽车的共性
}

    2.假设 N年后，制造商要设计一款新车的话：          

public   class  XXXCar : Car    // 继承了原来汽车的一些共性
... {
 //……
 public override string Dec()
 ...{  
    return " XXXCar " };   // 重写了汽车的一个特性
}

    3.ok新车的设计好了，我们又可以造车了；

XXXCar xxx =   new  XXXCar()；

    现在的结构如下：

  

===ok，以上所说的都是汽车制造过程中的第一步，及设计上的。下面来看看汽车制造过程中的问题====

简单工厂模式

1.从程序的角度来看：

     定义完class后就可以new出该class的实例。但在处理具体项目的时候，在定义完class后，往往要做一些其他的操作，才能new出该class的实例。比如类里面一些变量的赋值，条件的判断等等。当然这些操作，可以使用构造函数来实现。但是如果在一个项目中这个class的实例如果要多次用到的化，那构造函数就会很复杂，系统的开销就很大了；

 

2.从实际问题来看：  

     汽车制造商在设计完汽车后，不可能直接就去制造汽车了，肯定要先对汽车制造过程中用的所有东西进行准备。一切准备完了后才可以制造汽车。

    还有如果制造商制造每一辆汽车的时候，都要去准备一次东西。那肯定是不可能的（除非特殊情况，比如某个明星花钱定做了一辆的汽车。那没办法，人家有钱呵呵）。最好的解决办法就是：建一个工厂，将工作分开，有专门的人去准备东西。工厂只要负责根据设计制造汽车就可以。

 

3.代码来看就是：

  

   //还是以buick为例

  

   //设计一个造buick的工厂类

Public  class  BuickFactory 
... {
    //……  其他准备操作
 Public BuickCar Create()    //制造汽车；
 ...{
      Return new BuickCar() ;
  }
}

  

   // 客户端代码

BuickFactory buickfactory  =   new  BuickFactory();  // 建造一个buick的汽车工厂
BuickCar buick =  buickfactory.Create();  //

  

   结构：

 

     

   ===以上模式就是简单工厂模式。

抽象工厂模式

继续进一步思考问题：
    
   假设现在制造商不造buick 改造benze了。如果用简单工厂模式的问题就变成了：制造商不但要设计benze的工厂，还要重新为benze去建个工厂.（简单工厂模式的弱点）

   Benze工厂类设计（同buick）：

   //客户端代码

BenzeFactory benzefactory  =   new  BenzeFactory ();   // 建造一个benze的汽车工厂
BenzeCar benze =  benzefactory.Create();                   //

    从上面的代码可以看出，如果在一个项目中有很多这样的代码要修改的话，就会非常麻烦！

    (看来制造商需要对工厂进行重组了,呵呵)

1.从实际问题来看
 
　　参见汽车设计的过程：其实工厂在制造每种汽车的过程中有很多东西是可以一起处理。即时不能一起处理，处理方式也可能一样（比如对汽车烤漆的工作）。
　　制造商对工厂的重组就是：建一个汽车工厂，工厂准备好东西，对不同的汽车开设不同的生产线来生产。

2.将上面的问题解释到程序上就是：

　　我们设计一个抽象的工厂类，定义好抽象的方法（烤漆），让子工厂类去重写（因为不知道每一种车要如何烤漆）

3.代码

   //设计抽象工厂类

public   abstract   class  CarFactory 
... {
   // ……;准备
  public abstract Car Create(); //造车
}

   //设计buick的子工厂类 继承 工厂类

Public  class  BuickFactory : CarFactory
... {
   //……;准备
  Public class Car Create()   
  ...{
   Return new BuickCar();  //返回buickcar的实例
 }
}

    //设计benze的子工厂类

Public  class  BenzeFactory : CarFactory
... {
   // …… 准备
 Public class Car Create()   //
  ...{
   Return new BenzeCar();  // 返回benzecar的实例
 } 
}

    Ok，来看一下具体的代码调用:

CarFactory  carfactory  ;    //   定义一个工厂（此处代码分开写看的更清除一些）  

carfactory  =   new  BuickFactory() ;    //  现在要生产buick车，那就开条buick的生产线出来，如果要改造benze的话只要 new BenzeFactory()就可以了。

Car car  =  carfactory.Create();  //  buick的生产线生成buick了

    注：其实对于第三行代码还有一种写法：
       BuickCar buick = （BuickCar）carfactory.Create()；但是这样在代码维护的时候还是要修改2次，还是很麻烦。虽然不能避免修改，但是可以减少修改。（buick的生产线也不可能生产出benze的,呵呵）

    以上结构：
       

以上就是抽象工厂模式

（ 写玩了，刚学.net ，以上就是个人对简单工厂模式和抽象工厂模式的理解!写的不对请指正，呵呵！）

          b.   一切 ok 后，就可以制造汽车了；