设计模式-创建型模式

创建型模式：

工厂方法

核心：客户端调用具体的工厂，让工厂去决定实例化哪个具体的类。
核心代码为工厂类创建对应的具体的类，表现为和对应的具体类的依赖关系。

//抽象工厂类
  Interface Productfactory
  {
    Product CreateProduct();
  }
//具体A工厂
 class ConcreteProductFactoryA：Productfactory
  {
    public Product CreateProduct()
    {
       return new ConcreteProductA();
    }
  }
//具体产品B工厂
class ConcreteProductFactoryB：Productfactory
  {
    public Product CreateProduct()
    {
       return new ConcreteProductB();
    }
  }

抽象工厂

核心：一个工厂类可以创建一个品牌的一系列产品
核心代码：

//抽象工厂类
  Interface Productfactory
  {
    Product CreateProduct();

  }
//具体1号品牌工厂
 class ConcreteFactory1：Productfactory
  {
      //生产1号品牌的A产品
    public Product CreateProductA()
    {
       return new ConcreteProductA1();
    }
     //生产1号品牌的B产品
     public Product CreateProductB()
    {
       return new ConcreteProductB1();
    } 
  }

//具体2号品牌工厂
class ConcreteFacotry2：Productfactory
  {
  //生产2号品牌的A产品
    public Product CreateProductA()
    {
       return new ConcreteProductA2();
    }
     //生产2号品牌的B产品
     public Product CreateProductB()
    {
       return new ConcreteProductB2();
    }
 }

建造者

核心：builder类封装具体的表现形式,Director类封装具体的建造过程。
通过聚合指挥者拥有建造者对象，指挥者让建造者去做具体的事情。
核心代码：

//建造过程
class Director 
{
  public void Construct(Builder builder)
  {
     builer.BuildePartA();
      builer.BuildePartB();
     builer.GetResult();
  } 
}
abstract class AbstractBuilder      
{          
  public abstract  void BuildPartA(); 
  public abstract  void BuildPartB(); 
  public abstract  void GetResult();        
}      

 //具体的表现
 class ConcreteBuilder : AbstractBuilder     
  { 
    public override void BuildPartA()        
      { 
      product.add("部件A")             
      }  
    public override void BuildPartB（）
      {
        product.add("部件B");
      }
    public override void BuildPartB（）
      {
         return product;
      }
 }

原型

核心：通过拷贝让原型创建新的实例

 abstact class prototype
 {
 public abstract Protype Clone(); 
 }

 class ConcretePrototype1:Prototype
 {
    public override Protetype Clone()
    {
      return (Protetype)this.MemberwiseClone();
    }
 }

总结：
创建型模式都是在创建对象的过程，像工厂是通过在工厂类里面返回一个具体的要创建的对象（依赖关系），在建造者里面是把builder类作为参数传给Director类，然后在director类的方法里面，调用builder对象，去执行builder 的方法。（聚合关系）。学习，对比联系抽象，这样效率才更高，不断实践。