Factory Method工厂方法(创建型模式)

Factory Method --- 工厂方法

从耦合关系谈起

耦合关系直接决定着软件面对变化时的行为

--模块与模块之间的紧耦合使得软件面对变化时，相关的模块都要随之更改

--模块与模块之间的松耦合使得软件面对变化时，一些模块更容易被替换或者更改，但其他模块保持不变

 

 

 软件需求的变化不应该是工程师抱怨的问题，而应该是工程师要解决的问题

主要的部分---抽象的高层部分---变化慢

细节的部分---具体的实现部分---变化快

细节依赖于主干

 

动机(Motivation)

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

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

意图(Intent)

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

结构

        static void Main(string[] args)
        {
            CarTestFramWork cartestframwork = new CarTestFramWork();
            cartestframwork.BuilderTestContext(new HongqicarFactory());
            cartestframwork.BuilderTestContext(new DongfengCarFactory());
        }

        //AbstractCar.cs,汽车模型

        abstract class AbstractCar
        {
            public abstract void StartUp() ;
            public abstract void Run();
            public abstract void Trun(Direction direction;
            public abstract void Stop();
        }

        abstract class CarFactory
        {
            public abstract AbstractCar CreateCar();
        }

        //CarTestFramWork.cs  --- 测试不同类型的AbstractCar

        class CarTestFramWork
        {
            public void BuilderTestContext(CarFactory carFatory)  //要用到不定的多个car(关键)
            {
                AbstractCar c1 = carFatory.CreateCar();
                AbstractCar c2 = carFatory.CreateCar();
                AbstractCar c3 = carFatory.CreateCar();

            }
            public void DoTest(AbstractCar car)
            {
                car.Run();

            }
            public TestData GetTestData(AbstractCar car)
            {
                car.Stop();
            }
        }

        //HongQiCar.cs

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

            public override void StartUp() {}
            public override void Run(){}
            public override void Trun(Direction direction{}
            public override void Stop(){}
        }

        class HongqicarFactory : CarFactory
        {
            public override AbstractCar  CreateCar()
            {
                return new HongQiCar():  //这个地方可以做成一个Factory来控制实例的输出
            }
        }

        //DongfengCar.cs --- 扩展，而不更改原来的结构
        public class DongfengCar : AbstractCar
        {
            Enginee enginee1;
            Enginee enginee2;

            public override void StartUp() {}
            public override void Run(){}
            public override void Trun(Direction direction{}
            public override void Stop(){}
        }

        class DongfengCarFactory : CarFactory
        {
            public override AbstractCar  CreateCar()
            {
                return new DongfengCar():
            }
        }