Abstract Factory 抽象工厂模式(创建型模式)

　　说到对象的创建，我们第一想到的就是New。但New带来的问题是实现依赖，不能应对“具体实例类型”的变化。创建型模式其实就是解决Ｎew的问题。
哪里变化，封装哪里。我们认为对象的创建存在变化，因为我们封装对象创建。
例１：对象创建

class  Road
{
}
class  Test
{
  static void Main()
 {
   Road road = new Road();
 }
}

若路是经常变化的，则路的创建是变化的，封装变化点。new是变化点。
例２：封装对象创建

class  Road
{
}
class  RoadFactory
{
  public static Road CreateRoad()
  {
      return new Road();
  }
}

class  Test
{
   static void Main()
   {
      Road road = RoadFactory.CreateRoad();
   }
}

RoadFactory是变化点。
例２：创建一系列相互依赖的对象

class  Wall
{
}
class  Window
{
}
class  Floor
{
}
class  House
{
   Wall w;
   Window wi;
   Floor f;
   public House(Wall w,Window wi,Floor f)
   {
     this.w=w;this.wi=wi;this.f=f;
   }
}
class  HouseFactory
{
  public static Wall CreateWall()
  {
     return new Wall();
  }
  public static Window CreateWindow()
  {
     return new Window();
  }
  public static FloorCreateFloor()
  {
     return new Floor();
  }
}
// 创建房子，由墙，窗户，地板组成
class  Test
{
  static void Main()
  {
     Wall w = HouseFactory.CreateWall();
     Window wi = HouseFactory.CreateWindow();
     Floor f = HouseFactory.CreateFloor();
     House h = new House(w,wi,f);
  }
}

若需要创建不同风格的House，如古典房子：砖墙、木窗、砖地板。现代房子：水泥墙、铝窗、水泥
地板。这就是简单(静态)工厂模式的问题所在，不能应对“不同系列对象”的变化。HouseFactory是变化点，这是抽象工厂模式需要解决的问题。
例３：抽象工厂

public   abstract   class  Wall
{
}
Wall #region Wall
public class Wallx:Wall
{
}
public class Wally:Wall
{
}
#endregion
public   abstract   class  Window
{
}
Window #region Window
public class Windowx:Window
{
}
public class Windowy:Window
{
}
#endregion
public   abstract   class  Floor
{
}
Floor #region Floor
public class Floorx:Floor
{
}
public class Floory:Floor
{
}
#region
public class House
{
   Wall w;
   Window wi;
   Floor f;
   public House(Wall w,Window wi,Floor f)
   {
     this.w=w;this.wi=wi;this.f=f;
   }
}
//抽象工厂
public abstract class HouseFactory
{
  public abstract Wall CreateWall();
  public abstract Window CreateWindow();
  public abstract Floor CreateFloor();
}
HouseFactory#region HouseFactory
class HouseFactoryx:HouseFactory
{
  public override Wall CreateWall()
  {
     return new Wallx();
  }
  public override Window CreateWindow()
  {
     return new Windowx();
  }
  public override Floor CreateFloor()
  {
     return new Floorx();
  }
}
class HouseFactoryy:HouseFactory
{
  public override Wall CreateWall()
  {
     return new Wally();
  }
  public override Window CreateWindow()
  {
     return new Windowy();
  }
  public override Floor CreateFloor()
  {
     return new Floory();
  }
}
#endregion
//创建房子，由墙x，窗户x，地板x或墙y，窗户y，地板y组成。代有2个系列。
class Test
{
  static void Main()
  {
     HouseFactory houseFactory = new HouseFactoryx();
     //HouseFactory houseFactory = new HouseFactoryy();
     Wall w = houseFactory.CreateWall();
     Window wi = houseFactory.CreateWindow();
     Floor f = houseFactory.CreateFloor();
     House h = new House(w,wi,f);
  }
}

　
　　生成x系列的House还是y系列的房子，客户程序仅需要修改一行代码。其实把这种改变写到配置文件中将不需要重新编译代码就能得到不同系列的房子。利用反射技术创建HouseFactory的对象。

一、动机(Motivation)
   在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化往往存在“更多系列对象”的创建工作。
　如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种多系列具体对象创建工作的紧密耦合？
二、意图(Intent)
  提供一个接口，让该接口负责创建一系列相关或者相互依赖的对象，无需指定它们具体的类。
三、结构(Structure)

<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

ＰＳ：
如果没有应对“多系列对象构建”的需求变化，则没有必要使用abstract factory模式，这时使用简单的静态工厂完全可以。
“系列对象”指的是这些对象之间有相互依赖，或作用的关系。
abstract factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

转载于:https://www.cnblogs.com/hotsoho.net/articles/328893.html