创建型模式之工厂、简单工厂、抽象工厂简单图析和代码分析笔记

资料来源：吕震宇老师博客

简单工厂：

using System;

public abstract class Light
{
   public abstract void TurnOn();
   public abstract void TurnOff();
}

public class BulbLight : Light
{
   public override void TurnOn()
   {
      Console.WriteLine("Bulb Light is Turned on");
   }

   public override void TurnOff()
   {
      Console.WriteLine("Bulb Light is Turned off");
   }
}

public class TubeLight : Light
{
   public override void TurnOn()
   {
      Console.WriteLine("Tube Light is Turned on");
   }

   public override void TurnOff()
   {
      Console.WriteLine("Tube Light is Turned off");
   }
}

public class LightSimpleFactory
{
   public Light Create(string LightType)
   {
      if(LightType == "Bulb")
         return new BulbLight();//“基类返回类型多么写意啊  ”！！！ 
      else if(LightType == "Tube")
         return new TubeLight();
      else
         return null;
   }
}

public class Client
{
   public static void Main()
   {
      LightSimpleFactory lsf = new LightSimpleFactory();

      Light l = lsf.Create("Bulb");//这里是核心，“基类无敌了，把子类方法使唤”！！ 
      l.TurnOn();
      l.TurnOff();

      Console.WriteLine("-----------------");

      l = lsf.Create("Tube");
      l.TurnOn();
      l.TurnOff();
   }
}

简单工厂图例：

分析：两个具体产品出自于抽象产品，而具体产品的生产直接交给一个具体的工厂去完成。优点是：客户不用知道产品具体是怎么生产的，直接交给工厂即可。

缺点是：当要扩展生产其他产品的时候，具体工厂就显得臃肿复杂了，而且还要修改。

工厂模式：

program：

using System;

public abstract   class Light
{
   public abstract void TurnOn();
   public abstract void TurnOff();
}

public class BulbLight : Light
{
   public override void TurnOn()
   { Console.WriteLine("Bulb Light is Turned on"); }

   public override void TurnOff()
   { Console.WriteLine("Bulb Light is Turned off"); }
}

public class TubeLight : Light
{
   public override void TurnOn()
   { Console.WriteLine("Tube Light is Turned on"); }

   public override void TurnOff()
   { Console.WriteLine("Tube Light is Turned off"); }
}

public abstract   class Creator//这个抽象工厂是亮点 
{
   public abstract Light factory();
}

public class BulbCreator : Creator//对客户的要求进行松耦合，说白些就是对每一个客户我就大方的分配一个工厂帮你搞产品外包 
{
   public override Light factory()
   { return new BulbLight(); }
}

public class TubeCreator : Creator
{
   public override Light factory()
   { return new TubeLight(); }
}

public class Client
{
   public static void Main()
   {
      Creator c1 = new BulbCreator();//客户知道总公司是谁，且知道自己一直合作的分工厂是谁，就找到谁 
      Creator c2 = new TubeCreator();

      Light l1 = c1.factory();//客户知道自己的产品分类的科目，这个是具体运行了 
      Light l2 = c2.factory();

      l1.TurnOn();
      l1.TurnOff();

      Console.WriteLine("-----------------");

      l2.TurnOn();
      l2.TurnOff();
   }
}

工厂模式图例：

简单分析：工厂模式的优点是：把工厂的负担减小了，同时使得分工更加明显。

缺点：囧。上课没记住~~~

抽象工厂模式：

program：

// Abstract Factory pattern -- Structural example  
using System;

// "AbstractFactory"
abstract class AbstractFactory//抽象工厂 
{
  // Methods
  abstract public AbstractProductA CreateProductA();//具体工厂具体方法，方法可以是组合，使得业务逻辑更符合常识 
  abstract public AbstractProductB CreateProductB();
}

// "ConcreteFactory1"
class ConcreteFactory1 : AbstractFactory//工厂1：生产产品A1和产品B1 
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA1();
  }
  override public AbstractProductB CreateProductB()
  {
    return new ProductB1();
  }
}

// "ConcreteFactory2"
class ConcreteFactory2 : AbstractFactory//产品2：生产产品A2和B2 
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA2();
  }

  override public AbstractProductB CreateProductB()
  {
    return new ProductB2();
  }
}

// "AbstractProductA"
abstract class AbstractProductA//产品A系列的鼻祖 
{
}

// "AbstractProductB"
abstract class AbstractProductB//产品B系列的鼻祖，不过和A系列搅合在一块，“用了对象组合” 
{
  // Methods
  abstract public void Interact( AbstractProductA a );
}

// "ProductA1"
class ProductA1 : AbstractProductA//具体A系列的产品 
{
}

// "ProductB1"
class ProductB1 : AbstractProductB//具体B系列的产品，当然也把自己的组合部件A系列输出，不过输出A系列的哪个部件，这还是看具体工厂下达的命令 
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}

// "ProductA2"
class ProductA2 : AbstractProductA
{
}

// "ProductB2"
class ProductB2 : AbstractProductB
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}

// "Client" - the interaction environment of the products
class Environment//客户的命令在这个环境进行处理，找到相应工厂 
{
  // Fields
  private AbstractProductA AbstractProductA;
  private AbstractProductB AbstractProductB;//这个对象组合感觉太拘谨了，搞得非要生产AB一样 
   

  // Constructors
  public Environment( AbstractFactory factory )//这个工厂“基类”老大霸气侧漏！ 
  {
    AbstractProductB = factory.CreateProductB();
    AbstractProductA = factory.CreateProductA();
  }
 
  // Methods
  public void Run()
  {
    AbstractProductB.Interact( AbstractProductA );
  }
}

/// <summary>
/// ClientApp test environment
/// </summary>
class ClientApp
{
  public static void Main(string[] args)
  {
    AbstractFactory factory1 = new ConcreteFactory1();
    Environment e1 = new Environment( factory1 );//客户想工厂1发出命令 
    e1.Run();

    AbstractFactory factory2 = new ConcreteFactory2();
    Environment e2 = new Environment( factory2 );
    e2.Run();
  }
}

抽象工厂图例：