工厂模式

汽车及测试程序的演化过程：
Part 1：

class Car
{
 Enigee enigee;
 public void startup(){}
 public void Run(){}
 public void Turn(Direction direction){}
 public void Stop(){}
}
class CarTestFramework
{
 public void BuildTestContext()
 {
  Car car = new Car();
  //
 }
 public void DoTest()
 {
  Car car = new Car();
  //
 }
 public TestData GetTestData()
 {
  Car car = new Car();
  //
 }
}

Part 2：
问题：CarTestFramework只能测试一种Car。
思路：把Car变成抽象类

abstract class AbstractCar
{
 public abstract void Startup();
 public abstract void Run();
 public abstract void Turn(Direction direction);
 public abstract void Stop();
}
Class CarTestFramework
{
 public void BuildTestContext(AbstractCar car)
 {
  car.startup();
 }
 public void DoTest(AbstractCar car1，AbstractCar car2)
 {
  car1.run();
  car2.run();
 }
 public TestData GetTestData(AbstractCar car){}
}

Part 3：
问题：方法里只能有固定的几个car，当需要传递的car个数不一定时会出现问题
思路：传递工厂类去创建对象

class HongqiCar:AbstractCar
{
 Enginee enginee1;
 Enginee enginee2;
 
 public override void Startup(){};
 public override void Run(){};
 public override void Turn(Direction direction){};
 public override void Stop(){};
}
class CarFactory
{
 public Car CreateCar()
 {
  return new HongqiCar();
 }
}
public void BuildTestContext(CarFactory carFactory)
{
 AbstractCar car1 = carFactory.CreateCar();
 AbstractCar car2 = carFactory.CreateCar();
 AbstractCar car3 = carFactory.CreateCar();
 AbstractCar car4 = carFactory.CreateCar();
}
class App
{
 public static void Main()
 {
  CarTestFramework carTestFarmework = new CarTestFramewrok();
  carTestFarmework.BuildTestContext(new CarFactory());
 }
}

Part 4：
问题：CarFactory和HongqiCar相互依赖（只能对应HongqiCar)
思路：抽象工厂CarFactory

abstract class CarFactory
{
 public abstract Car CreateCar();
}
public class HongqiCarFactory:CarFactory
{
 public override Car CreateCar()
 {
  return new HongqiCar();
 }
}
class App
{
 public static void Main()
 {
  CarTestFramework carTestFarmework = new CarTestFramewrok();
  carTestFarmework.BuildTestContext(new HongqiCarFactory());  //new DongfengCarFactory()或者读取配置文件
 }
}

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

PS:以下个人观点：

为什么要用抽象类？上述的AbstractCar为什么不用普通类来实现？

因为将一个类声明为抽象类，可以确保它的子类一定是在完成所有功能之后才能实例化（如果没有实现抽象类的方法，子类也必须声明为抽象类，而抽象类是不能实例化的）。如果用普通类，子类功能没有实现时也能实例化来使用，相当于交给用户一个未完成的零部件，这是应该避免的。