认识工厂模式(二)

之前的工厂模式(一)文章中所提到只是简单的工厂模式,本篇将以前篇为基础进入抽象工厂的说明.

抽象工厂模式是指拥有多个抽象角色时所使用的工厂模式，它可以为调用者提供一个接口，通过接口调用来创建产品，至于实现的细节并不需要关心。当拥有了多个抽象角色时，显然普通工厂已经不能满足要求了。根据LSP原则任何可以接收父类的地方同样可以接收子类。需求者往往得到是与抽象产品相同类型的实例，而并不是抽象产品本身的实例。工厂既然拥有多个抽象产品，但是在具体实例化的时候如何区分最终需要实例化哪个产品？其实很简单，一个抽象工厂拥有多个工厂角色每个工厂角色只负责一种抽象产品的实例化。在具体实例化的时候，哪种产品需实例化就相应调用哪种工厂角色来进行创建。说到这里我想你也应该明白一些，一般工厂只能创建单个产品，但是抽象工厂可以创建多个产品。

可以稍作一个简单的总结：

一般工厂抽象的是产品，在具体创建产品的是由工厂来判断。

工厂方法是由一步做了抽象，将产品以及创建产品的工厂做了抽象，这样要创建一个产品需要是相应的工厂。

抽象工厂是针对产品的种类进行了抽象以及工厂也同样做了抽象。同样抽象工厂具备了相应的抽象产品的创建能力。这样所有继承工厂的类都可以创建出不同种类的产品的能力。

也许我描述的的不准确，这里结合网上的一样例代码你就会明白。

简单工厂:

using System; 
public interface ICar 
{ 
     void run(); 
} 

public class BMWCar : ICar 
{ 
     public void run() 
     { 
         Console.WriteLine("BMWCar run"); 
     } 
} 

public class BenzCar : ICar 
{ 
     public void run() 
     { 
         Console.WriteLine("BenzCar run"); 
     } 
} 

public class Driver 
{ 
     public static ICar DriverCar(string carType) 
     { 
         switch (carType) 
         { 
             case "BMWCar": return new BMWCar(); 
             case "BenzCar": return new BenzCar(); 
             default: throw new Exception(); 
        } 
     } 
} 

public class Client 
{ 
     public static void Main() 
     { 
         ICar myCar = Driver.DriverCar("BenzCar"); 
         myCar.run(); 
         Console.Read(); 
     } 
}

工厂方法:
using System; 
public interface ICar 
{ 
     void run(); 
} 

public class BMWCar : ICar 
{ 
     public void run() 
     { 
         Console.WriteLine("BMWCar run"); 
     } 
} 

public class BenzCar : ICar 
{ 
     public void run() 
     { 
         Console.WriteLine("BenzCar run"); 
     } 
} 
public abstract class Driver 
{ 
     public abstract ICar DriverCar(); 
} 

public class BMWDriver : Driver 
{ 
     public override ICar   DriverCar() 
     { 
         return new BMWCar(); 
     } 

} 
public class BenzDriver : Driver 
{ 
     public   override ICar DriverCar() 
     { 
         return new BenzCar(); 
     } 
} 

class Client 
{ 
     public static void Main() 
     { 
         Driver myDriver = new BenzDriver(); 
         ICar myCar = myDriver.DriverCar(); 
         myCar.run(); 
         Console.Read(); 
     } 
}

using System; 

public interface IBusinessCar 
{ 
     void run(); 
} 

public interface ISportCar 
{ 
void run(); 
} 

public class BMWBusinessCar : IBusinessCar 
{ 
     public void run() 
     { 
         Console.WriteLine("BMWCar run"); 
     }

}

public class BenzBusinessCar : IBusinessCar 
{ 
     public void run() 
     { 
         Console.WriteLine("BenzBusinessCar run"); 
     } 
} 

public class BMWSportCar:ISportCar 
{ 
public void run() 
{ 
Console.WriteLine("BMWSportCar run"); 
} 
} 

public class BenzSportCar:ISportCar 
{ 
public void run() 
{

Console.WriteLine("BenzSportCar run"); 
} 
} 

public interface IDriver 
{ 
IBusinessCar BusinessCarDriver(); 
ISportCar SportCarDriver(); 
} 

public class BMWDriver:IDriver 
{ 
public IBusinessCar BusinessCarDriver() 
{ 
return new BMWBusinessCar(); 
} 
public ISportCar SportCarDriver() 
{ 
return new BMWSportCar(); 
} 
} 

public class BenzDriver:IDriver 
{ 
public IBusinessCar BusinessCarDriver() 
{ 
return new BenzBusinessCar(); 
} 

public ISportCar SportCarDriver() 
{ 
return new BenzSportCar(); 
} 
}


class Client 
{ 
     public static void Main() 
     { 
         IDriver myDriver =new BenzDriver(); 
         ISportCar myCar = myDriver.SportCarDriver(); 
         myCar.run(); 
         Console.Read(); 
     }

}