OO设计模式_工厂方法模式

Motivation
在软件系统中，经常面临着“某个对象”的创建工作；由于需求的变化，这个对象经常面临着剧烈的变化，但是它却拥有比较稳定的接口。

如何应对这种变化？如果提供一种“封装机制”来隔离出“这个异变对象”的变化，从而保持系统中“其他依赖该对象的对象”不随着需求改变而改变。

Intent
定义一个用于创建对象的接口，让子类决定实例化哪个类。Factory Method使得一个类的实例化延迟到子类。

Structure

Code

不使用设计模式

class Car
{
    Engine engine;
    Brand brand;
    void Startup()
    {

    }
    void Run()
    {

    }
    void Stop()
    {

    }
    void Turn(Direction d)
    {

    }
}

class CarTestFramework 
{
    void BuildTextContext()
    {
        Car car = new Car();
        //...
    }
    void DoTest()
    {
        Car car = new Car();
        //...
    }
    TestData GetTestData()
    {
        Car car = new Car();
        //...
    }
}

使用Factory Method

abstract class AbstractCar
{
    Engine engine;
    Brand brand;
    abstract void Startup()
    {
        //...
    }
    abstract void Run()
    {
        //...
    }
    abstract void Stop()
    {
        //...
    }
    abstract void Turn(Direction d)
    {
        //...
    }
}
class VWCar : AbstractCar
{
    Engine engine;
    Brand brand;
    override void Startup()
    {
        //...
    }
    override void Run()
    {
        //...
    }
    override void Stop()
    {
        //...
    }
    override void Turn(Direction d)
    {
        //...
    }
}
class TOYOTACar : AbstractCar
{
    Engine engine;
    Brand brand;
    override void Startup()
    {
        //...
    }
    override void Run()
    {
        //...
    }
    override void Stop()
    {
        //...
    }
    override void Turn(Direction d)
    {
        //...
    }
}
interface ICarFactory
{
    public AbstractCar CreateCar();
}

class VWCarFactory : ICarFactory
{
    public AbstractCar CreateCar()
    {
        return new VWCar();
    }
}

class TOYOTACarFactory : ICarFactory
{
    public AbstractCar CreateCar()
    {
        return new TOYOTACar();
    }
}

class CarTestFramework
{
    void BuildTextContext(CarFactory carFactory)
    {
        AbstractCar car = carFactory.CreateCar();
        car.Starup();
        //...
    }
    void DoTest(AbstractCar car)
    {
        car.Run();
        //...
    }
    TestData GetTestDataAbstractCar(AbstractCar car)
    {
        car.Stop();
        //...
    }
}
class App
{
    public static void Main()
    {
        ICarFactory carFactory = new VWCarFactory();
        CarTestFramework carTestFramework=new CarTestFramework();
        carTestFramework.BuildTextContext(carFactory);

        ICarFactory carFactory = new TOYOTACarFactory();
        CarTestFramework carTestFramework = new CarTestFramework();
        carTestFramework.BuildTextContext(carFactory);
    }
}

Main Point
Factory Method模式主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。

Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非改变）的策略，较好的解决了这种紧耦合的关系。

Factory Method模式解决“单个对象”的需求变化，Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。