C#面向对象设计模式纵横谈 学习笔记5 Factory Method 工厂方法（创建型模式）

1、Factory Method工厂方法模式的动机在软件系统中，经常面临着"某个对象"的创建工作；由于需求的变化，这个对象经常面临着剧烈的变化，但是它却拥有比较稳定的接口。如何应对这种变化？如何提供一种"封装机制"来隔离出"这个易变对象"的变化，从而保持系统中"其他依赖该对象的对象"不随着需求改变而改变？

2、Factory Method工厂方法模式的意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类。

现在看看Factory Method的代码实现方式

首先是一个抽象类AbstractCar，代表所有车类型的抽象类

 

public abstract class AbstractCar
...{
    public abstract void StartUp();

    public abstract void Run();


    public abstract void Turn(Direction direction);


    public abstract void Stop();
}

接下来是一个抽象类，代表Car的工厂，由这个类来产生Car

 

public abstract class AbstractCarFactory
...{
    public abstract AbstractCar CreateCar();
}

接下来是一个具体的Car类型，它继承预AbstractCar，并实现了里面的抽象方法

public class HongQiCar : AbstractCar
...{
    Enginee enginee1;
    Enginee enginee2;
    Enginee enginee3;
    Enginee enginee4;

    public override void StartUp()
    ...{
    }

    public override void Run()
    ...{
    }

    public override void Turn(Direction direction)
    ...{
    }

    public override void Stop()
    ...{
    }
}

 

那么对应的，就应该有一个红旗Car对应的工厂，它继承于AbstractCarFactory

public class HongQiCarFactory : AbstractCarFactory
...{
    public override AbstractCar CreateCar()
    ...{
        return new HongQiCar();
    }
}

接下来是一个具体使用到Car和CarFactory的Car的测试类

public class CarTestFramework
...{
    public void BuildTestContext(AbstractCarFactory carFactory)
    ...{
        AbstractCar car1 = carFactory.CreateCar();

        AbstractCar car2 = carFactory.CreateCar();
    }

    public void DoTest(AbstractCarFactory carFactory)
    ...{
        AbstractCar car1 = carFactory.CreateCar();
        car1.Run();
    }

    public TestData GetTestData(AbstractCarFactory carFactory)
    ...{
        //....
    }
}

那么上面的代码，我们知道我们使用CarTestFramework的时候，只需要传入一个抽象工厂，由这个工厂来创建对应的car类型

public static void Main()
...{
    CarTestFramework ctf = new CarTestFramework();
    ctf.BuildTestContext(new HongQiCarFactory());
}

在这个Main函数里，我们可以通过配置文件l利用反射创建不同的CarFactory的类型

看到这里，觉得Factory Method有点类似于Abstract Factory模式，这里我们对比一下这两个模式

首先是抽象类和抽象工厂类

public abstract class Road
...{
}
public abstract class Building
...{
}

public abstract class Tunnel
...{
}

public abstract class Jungle
...{
}

public abstract class FacilitiesFactory
...{
    public abstract Road CreateRoad();
    public abstract Building CreateBuilding();
    public abstract Tunnel CreateTunnel();
    public abstract Jungle CreateJungle();
}

那么派生对象和派生工厂如下

public class ModenRoad : Road
...{
}

public class ModenBuilding : Building
...{
}

public class ModenTunnel : Tunnel
...{
}

public class ModenJungle : Jungle
...{
}

public class ModenFacilitiesFactory : FacilitiesFactory
...{

    public override Road CreateRoad()
    ...{
        return new ModenRoad();
    }

    public override Building CreateBuilding()
    ...{
        return new ModenBuilding();
    }

    public override Tunnel CreateTunnel()
    ...{
        return new ModenTunnel();
    }

    public override Jungle CreateJungle()
    ...{
        return new ModenJungle();
    }
}

可以对比到Abstract Factory和Factory Method模式很类似，但是Factory Method是解决单个对象的需求变化，而Abstract Factory解决的是一系列对象的需求变化。

Factory Method模式的几个要点

• Factory Method模式主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。
• Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一
  种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
• Factory Method模式解决"单个对象"的需求变化，Abstract Factory 模式解决"系列对象"的需求变化，Builder模式解决"对象部分"的需求变化。