工厂方法模式

一、 工厂方法（Factory Method）模式

工厂方法（FactoryMethod）模式是类的创建模式，其用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。

工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节。这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

在Factory Method模式中，工厂类与产品类往往具有平行的等级结构，它们之间一一对应。

二、 Factory Method模式角色与结构：

抽象工厂（Creator）角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

具体工厂（Concrete Creator）角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与TubeCreator。

抽象产品（Product）角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。

具体产品（Concrete Product）角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

三、 程序举例：

//产品
public abstract class Car
{
    public abstract void Startup();
    public abstract void Run();
    public abstract void Stop();
}

public class Truck : Car
{
    public override void Startup()
    {
        Console.WriteLine("Truck Startup.");
    }

    public override void Run()
    {
        Console.WriteLine("Truck Run.");
    }

    public override void Stop()
    {
        Console.WriteLine("Truck Stop.");
    }
}

public class Bus : Car
{
    public override void Startup()
    {
        Console.WriteLine("Bus Startup.");
    }

    public override void Run()
    {
        Console.WriteLine("Bus Run.");
    }

    public override void Stop()
    {
        Console.WriteLine("Bus Stop.");
    }
}

//工厂
public abstract class CarFactory
{
    public abstract Car CreateCar();
}

public class TruckFactory : CarFactory
{
    public override Car CreateCar()
    {
        return new Truck();
    }
}

public class BusFactory : CarFactory
{
    public override Car CreateCar()
    {
        return new Bus();
    }
}

//业务
public class DriveCar
{
    public static void driveCar(Car car)
    {
        car.Startup();
        car.Run();
        car.Stop();
    }
}

//调用
public class Client
{
    public static void Main()
    {
        TruckFactory truckFactory = new TruckFactory();
        Car truck = truckFactory.CreateCar();
        DriveCar.driveCar(truck);

        BusFactory busFactory = new BusFactory();
        Car bus = busFactory.CreateCar();
        DriveCar.driveCar(bus);
    }
}

扩张：

在上面的代码中，可以使用泛型进一步简化抽象工厂类和具体工厂类。代码示例：

//产品
public abstract class Car
{
    public abstract void Startup();
    public abstract void Run();
    public abstract void Stop();
}

public class Truck : Car
{
    public override void Startup()
    {
        Console.WriteLine("Truck Startup.");
    }

    public override void Run()
    {
        Console.WriteLine("Truck Run.");
    }

    public override void Stop()
    {
        Console.WriteLine("Truck Stop.");
    }
}

public class Bus : Car
{
    public override void Startup()
    {
        Console.WriteLine("Bus Startup.");
    }

    public override void Run()
    {
        Console.WriteLine("Bus Run.");
    }

    public override void Stop()
    {
        Console.WriteLine("Bus Stop.");
    }
}

//构造工厂
public  class CarFactory<T> where T : new()
{
    public static T CreateCar()
     {
        T car = new T();
        return car;
    }

}

//业务
public class DriveCar
{
    public static void driveCar(Car car)
    {
        car.Startup();
        car.Run();
        car.Stop();
    }
}

//调用
public class Client
{
    public static void Main()
    {
        Car truck = CarFactory<Truck>.CreateCar();  
        DriveCar.driveCar(truck);

        Car bus = CarFactory<Bus>.CreateCar();
        DriveCar.driveCar(truck);
    }
}

四、 工厂方法模式与简单工厂模式

工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。

工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。

当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了"开放－封闭"原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。

工厂方法模式退化后可以演变成简单工厂模式。

五、 Factory Method模式演化

使用接口或抽象类

抽象工厂角色和抽象场频角色都可以选择由接口或抽象类实现。

使用多个工厂方法

抽象工厂角色可以规定出多于一个的工厂方法，从而使具体工厂角色实现这些不同的工厂方法，这些方法可以提供不同的商业逻辑，以满足提供不同的产品对象的任务。

产品的循环使用

工厂方法总是调用产品类的构造函数以创建一个新的产品实例，然后将这个实例提供给客户端。而在实际情形中，工厂方法所做的事情可以相当复杂。

一个常见的复杂逻辑就是循环使用产品对象。工厂对象将已经创建过的产品登记到一个聚集中，然后根据客户所请求的产品状态，向聚集查询。如果有满足要求的产品对象，就直接将产品返回客户端；如果聚集中没有这样的产品对象，那么就创建一个新的满足要求的产品对象，然后将这个对象登记到聚集中，再返还给客户端。"享元模式（Flyweight Pattern）"就是这样一个模式。

多态性的丧失和模式的退化

一个工厂方法模式的实现依赖于工厂角色和产品角色的多态性。在有些情况下，这个模式可以出现退化。

工厂方法返回的类型应当是抽象类型，而不是具体类型。调用工厂方法的客户端应当依赖抽象产品编程，而不是具体产品。如果工厂仅仅返回一个具体产品对象，便违背了工厂方法的用意，发生退化，这时就不再是工厂模式了。

工厂的等级结构：工厂对象应当有一个抽象的超类型。如果等级结构中只有一个具体工厂类的话，抽象工厂就可以省略，发生了退化。

六、 Factory Method模式与其它模式的关系

与工厂方法模式有关的模式还包括：
模板方法模式、MVC模式、享元模式、备忘录模式

七、 另外一个例子

// Factory Method pattern -- Real World example  

using System;
using System.Collections;

// "Product"
abstract class Page
{
}

// "ConcreteProduct"
class SkillsPage : Page
{
}

// "ConcreteProduct"
class EducationPage : Page
{
}

// "ConcreteProduct"
class ExperiencePage : Page
{
}

// "ConcreteProduct"
class IntroductionPage : Page
{
}

// "ConcreteProduct"
class ResultsPage : Page
{
}

// "ConcreteProduct"
class ConclusionPage : Page
{
}

// "ConcreteProduct"
class SummaryPage : Page
{
}

// "ConcreteProduct"
class BibliographyPage : Page
{
}

// "Creator"
abstract class Document
{
  // Fields
   protected ArrayList pages = new ArrayList();

  // Constructor
   public Document()
  {
    this.CreatePages();
  }

  // Properties
   public ArrayList Pages
  {
    get{ return pages; }
  }

  // Factory Method
   abstract public void CreatePages();
}

// "ConcreteCreator"
class Resume : Document
{
  // Factory Method implementation
   override public void CreatePages()
  {
    pages.Add( new SkillsPage() );
    pages.Add( new EducationPage() );
    pages.Add( new ExperiencePage() );
  }
}

// "ConcreteCreator"
class Report : Document
{
  // Factory Method implementation
   override public void CreatePages()
  {
    pages.Add( new IntroductionPage() );
    pages.Add( new ResultsPage() );
    pages.Add( new ConclusionPage() );
    pages.Add( new SummaryPage() );
    pages.Add( new BibliographyPage() );
  }
}

/**//// <summary>
///  FactoryMethodApp test
/// </summary>
class FactoryMethodApp
{
  public static void Main( string[] args )
  {
    Document[] docs = new Document[ 2 ];

    // Note: constructors call Factory Method
    docs[0] = new Resume();
    docs[1] = new Report();

    // Display document pages
     foreach( Document document in docs )
    {
      Console.WriteLine( " " + document + " ------- " );
      foreach( Page page in document.Pages )
        Console.WriteLine( " " + page );
    }
  }
}