标签：
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模式解决“对象部分”的需求变化。
标签：
原文地址：http://www.cnblogs.com/xanadu123/p/4220880.html
