设计模式之Factory Method 之学习笔记

设计模式之Factory Method 之学习笔记

                 

Factory Method 工厂方法

  我们知道耦合关系直接决定着软件面对变化的行为。

  1、模块与模块之间的紧耦合使得软件面对变化时，相关的模块都要随着更改
  2、模块与模块之间的松耦合使得软件面对变化时，一些模块更容易被替换或者更改， 
  但其他模块保持不变。 
 
   动机（Motivation）
  在软件系统中，经常面临着“某个对象”的创建工作；由于需求的变化，这个
对象的具体实现经常面临着剧烈的变化，但是它却拥有比较稳定的接口。

 如何应对这种变化？如何提供一种“封装机制”来隔离出“这个容易变对象”的变化，
从而保持系统中“其他依赖该对象的对象”不随着需求改变 而改变？
 
  意图（intent）
 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得
一个类的实例化延迟到子类。

 先看一个实例
  class Car
 {

   //启动
    public void StartUp()
    {

    }
    //运行
    public void Run()
    {

    }
    //转向
    public void Turn(Direction direction)
    {
      
     }
 //停止

    public void Stop()
    {

    }

  }

  //测试环境
  class CarTestFramework
   {

     public void BildTestContext()
     {
        //需要一个Car的实例。
        Car car=new Car();
       //...........
      }
     public void DoTest()
     {
        Car car=new Car();
         //..........
     }

     public TestData GetTestData()
     {
       Car car=new Car();
     }

    } 
 

   假设这个软件需要变化，我们这个测试环境不可能只测试这一种车 ，上面的代码
就定死了这一个测试环境只能测试这种车，他是一个强依赖的关系。

  但是我们目前的需求要测试不同的车，这又该怎么办？

  我们改变一下上面的代码，我们把Car变成一个抽象类

 abstract class AbstractCar
 {

   //启动
    public abstract void StartUp();
    //运行
    public abstract  void Run();
    //转向
    public abstract  void Turn(Direction direction);
    //停止
    public abstract  void Stop();
  }
    
 
  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()
    {

    }

  }
 
 abstract CarFactory
{
 public abstract AbstractCar  AbstractCarCreateCar();
}

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

   }

  //测试环境
  class CarTestFramework
   {

     public void BildTestContext(CarFactory car)
     {
        //需要一个Car的实例。
         car.startup();
       //...........
      }
     public void DoTest(CarFactory car)
     {
       
         //..........
         car.run();
     }

    //获取汽车参数
     public TestData GetTestData(CarFactory car)
     {
     
     }

    } 

  class App
 {
     public static void Main()
    {
     CarTestFramework carTestFramework=new  CarTestFramwork();
     carTestFramework=new.BuildTestContext(new HongQiCarFactory());
   }
  }

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

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

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