学步园

从耦合关系谈起-耦合关系直接决定着软件面对变化时的行为[设计模式研究的是模块与模块之间的关系]
    – 模块与模块之间的紧耦合使得软件面对变化时，相关的模块都要随之更改
    – 模块与模块之间的松耦合使得软件面对变化时，一些模块更容易被替换或者更改，但其他模块保持不变 

        一个原则：变化快的东西不要影响变化慢的东西。 接口是模块与模块之间连接的部分,是相对稳定的部分，如下图的小圆点。
动机（Motivation）
    在软件系统中，经常面临着“某个对象”的创建工作；由于需求的变化，这个对象经常面临着剧烈的变化，但是它却拥有比较稳定的接口。
    如何应对这种变化？如何提供一种“封装机制”来隔离出“这个易变对象”的变化，从而保持系统中“其他依赖该对象的对象”不随着需求改变而改变？ 
    每一种设计模式都会依赖于一个稳定的东西或者说某一部分是固定不变的。 
    意图（Intent）
        定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类。
结构（Structure）
    
           

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace FactoryMethod
{

    Product Type  | 产品类型#region Product Type  | 产品类型
    public abstract class Direction { }
    public abstract class Enginee { }
    #endregion

    Abstract Product  | 抽象产品#region Abstract Product  | 抽象产品
    public abstract class AbstractCar
    {
        public abstract void Startup();
        public abstract void Run();
        public abstract void Turn(Direction direction);
        public abstract void Stop();
    }
    #endregion

    HonqiCar Product | 具体产品#region HonqiCar Product | 具体产品
    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()
        {
            //.
        }

    }




    #endregion 
    
    DongfengCar Product | 具体产品#region DongfengCar Product | 具体产品

    public class DongfengCar : AbstractCar
    {
        Enginee enginee1;
        Enginee enginee2;

        public override void Startup()
        {
            //..
        }

        public override void Run()
        {
            //
        }

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

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

#endregion

    Abstract Factory | 抽象工厂#region Abstract Factory | 抽象工厂
    public abstract class CarFactory
    {
        public abstract AbstractCar CreateCar();
    }
    #endregion

    HonqiCar Factory | 具体工厂#region HonqiCar Factory | 具体工厂
    public class HongqiCarFactory : CarFactory
    {
        public override AbstractCar CreateCar()
        {
            return new HongqiCar();
        }
    }
    #endregion

    DongfengCar Factory | 具体工厂#region DongfengCar Factory | 具体工厂
    public class DongfengCarFactory : CarFactory
    {
        public override AbstractCar CreateCar()
        {
            return new DongfengCar();
        }
    }
    #endregion

    Client Application | 客户端应用程序#region Client Application | 客户端应用程序
    public class CarTestFramework
    {
        public void BuildTestContext(CarFactory carfactory)
        {
            AbstractCar c1 = carfactory.CreateCar();
            AbstractCar c2 = carfactory.CreateCar();
            AbstractCar c3 = carfactory.CreateCar();
            AbstractCar c4 = carfactory.CreateCar();
        
        }


    }
   

    class Program
    {
        static void Main(string[] args)
        {
            CarTestFramework carTestFramework = new CarTestFramework();
            carTestFramework.BuildTestContext(new HongqiCarFactory());
            carTestFramework.BuildTestContext(new DongfengCarFactory());

            //以上实倒化对象可以通过配置文件实现(参考Builder模式)
            //Activator.CreateInstance(TypeName) TypeName类的名称（这边可以用HongqiCarFactory或DongfengCarFactory）


        }
    }

    #endregion
}

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