设计模式 第一回 工厂模型

简单工厂模式

 定义：

专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类或接口。简单工厂模式又称为静态工厂方法（Static Factory Method）模式，属于类的创建型模式，通常根据一个条件（参数）来返回不同的类的实例。

意图：

提供一个类，由它负责根据一定的条件创建某一具体类的实例

参与者：

工厂角色：creater

产品角色：product 产品的抽象。所有产品的父类，描述所有具体产品公用的接口

具体产品：concrete product

实例：
 

 

using  System;
using  System.Text;

namespace  simpleFactory
{
     ///   <summary>
     ///  requirment:print paper according different type,including email print,document print.factory:printer,product:paper
     ///   </summary>
     public   interface  Iprint
    {
         void  GetPaper();
    }
     public   class  EmailPaper : Iprint
    {
         public   void  GetPaper()
        {
            Console.WriteLine( " this is email paper " );
        }
    }
     public   class  DocumentPaper : Iprint
    {
         public   void  GetPaper()
        {
            Console.WriteLine( " this is document paper " );
        }
    }

     public   class  Printer
    {
         public  Iprint CreatePaper(PaperType type)
        {
             switch  (type)
            {
                 case  PaperType.DocumentPaper:
                     return   new  DocumentPaper();
                 case  PaperType.EmailPaper:
                     return   new  EmailPaper();
                 default :
                     throw   new  Exception( " not implement " );
            }
        }
    }
     class  Program
    {
         static   void  Main( string [] args)
        {
            Iprint paper;
            Printer printer  =   new  Printer();
            Console.WriteLine( " get email paper " );
            paper  =  printer.CreatePaper(PaperType.EmailPaper);
            paper.GetPaper();
            Console.ReadLine();

        }
    }

     public   enum  PaperType
    {
        DocumentPaper,
        EmailPaper
    }
}

工厂方法：再简单工厂模式的基础上，如果我们不能清晰的明确具体工厂类，为了应对更多可能出现的具体工厂类的产生，需要将具体工厂类进行再次封装。

定义
工厂方法模式又称为工厂模式，也叫虚拟构造器（Virtual Constructor）模式或者多态工厂模式（Polymorphic Factory）,在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成， 即由子类来决定究竟应该实例化（创建）哪一个类。

意图
定义一个用户创建对象的接口，让子类决定实例化哪一个类，工厂方法模式使一个类的实例化延迟到其子类。 

 

 参与者：

 抽象产品角色（Product）定义产品的接口

具体产品角色（ConcreteProduct） 实现接口Product的具体产品类

抽象工厂角色（Creator）  

声明工厂方法（FactoryMethod），返回一个产品  

真实的工厂（ConcreteCreator） 实现FactoryMethod工厂方法，由客户调用，返回一个产品的实例

 

应用情景：

• 类不知道自己要创建哪一个对象时
• 类用它的子类来指定创建哪个对象
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候
  

 

实例：

using  System;
using  System.Reflection;

namespace  FactoryMethod
{
     ///   <summary>
     ///  requirment:print paper according different type,including email print,document print.factory:printer,product:paper
     ///   </summary>

     #region  product
     public   interface  Iprint
    {
         void  GetPaper();
    }
     #endregion

     #region  factory Function
     public   interface  Ifactory
    {
        Iprint CreatePrinter();
    }
     #endregion

     #region  concreate factory
     public   class  EmailFactory : Ifactory
    {
         public  Iprint CreatePrinter()
        {
             return   new  EmailPaper();
        }

    }

     public   class  DocumentFactory : Ifactory
    {
         public  Iprint CreatePrinter()
        {
             return   new  DocumentPaper();
        }

    }
     #endregion

     #region  concrete product
     public   class  EmailPaper : Iprint
    {
         public   void  GetPaper()
        {
            Console.WriteLine( " this is email paper " );
        }
    }
     public   class  DocumentPaper : Iprint
    {
         public   void  GetPaper()
        {
            Console.WriteLine( " this is document paper " );
        }
    }
     #endregion

   
     class  Client
    {
         static   void  Main( string [] args)
        {
            Console.WriteLine( " get email paper " );
            Ifactory printer  =  (Ifactory)Assembly.Load( " FactoryMethod " ).CreateInstance( " FactoryMethod.EmailFactory " );

            printer.CreatePrinter().GetPaper();
            Console.ReadLine();

        }
    }
}

 

缺点：

• 在添加新产品时，需要编写新的具体产品类（其实这不算一个缺点，因为这是不可避免的），要增加与之对应的具体工厂类。

 

抽象工厂模式：

Abstract Factory模式中，跟客户打交道的只有抽象工厂与抽象产品，客户不需要知道产品由哪个工厂生产，也不需要知道被生产的是哪一种具体的产品。　　

Abstract Factory模式通过抽象工厂为客户（调用者）生成多类产品，抽象工厂负责管理子工厂对象，子工厂负责生成某一类具体的产品对象。

Abstract Factory模式的应用场景：

- 存在多类产品，并需要对这些产品区别对待处理：需要分别为这些产品定义2个以上的接口或抽象类
- 客户端只需要与最上层的工厂（抽象工厂），与最上层的抽象产品打交道 

 

意图：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

参考者：
也就是该模式中的各个类或对象之间的关系：

• 抽象工厂（Abstract Factory)
  声明生成一系列抽象产品的方法
• 具体工厂（Concrete Factory）
  执行生成一系列抽象产品的方法，生成一系列具体的产品
• 抽象产品（Abstract Product）
  为这一系列的某一种产品声明接口
• 具体产品（Product）
  定义具体工厂生成的具体产品的对象，实现产品接口

 

代码

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  AbstractFactory
{
     public   abstract   class  CarFactory
    {
       
         public   abstract  AbstractBus CreateBus();
         public   abstract  AbstractTruck CreateTruck();
         public   static  CarFactory GetCarFactory( int  carType)
        {
             switch  (carType)
            {
                 case   1 :
                     return   new  BusTruckFactory();
                 case   2 :
                     return   new  ModelFactory();
                 default :  return   null ;

            }
        }
    }

     public   class  BusTruckFactory : CarFactory
    {
         public   override  AbstractBus CreateBus()
        {
             return   new  Bus();
        }
         public   override  AbstractTruck CreateTruck()
        {
             return   new  Truck();
        }

    }

     public   class  ModelFactory : CarFactory
    {
         public   override  AbstractBus CreateBus()
        {
             return   new  ModelBus();
        }
         public   override  AbstractTruck CreateTruck()
        {
             return   new  ModelTruck();
        }
    }

     public   class  AbstractBus
    {
         public   string  getType()
        {
             return   " AbstractBus " ;
        }
    }
     public   class  Bus : AbstractBus
    {
         public   string  getType()
        {
             return   " Bus " ;
        }
    }
     public   class  ModelBus : AbstractBus
    {
         public   string  getType()
        {
             return   " ModelBus " ;
        }
    }
     public   class  AbstractTruck
    {
         public   string  getType()
        {
             return   " AbstractTruck " ;
        }
    }
     public   class  Truck :AbstractTruck
    {
           public   string  getType()
        {
             return   " Truck " ;
        }
    }
     public   class  ModelTruck : AbstractTruck
    {
         public   string  getType()
        {
             return   " Model Truck " ;
        }
    }
     class  Program
    {
         static   void  Main( string [] args)
        {
            CarFactory factory  =  CarFactory.GetCarFactory( 1 );
            Bus bus = (Bus)factory .CreateBus ();
            Console .WriteLine ( " create: "   + bus.getType ());
            Truck truck = (Truck )factory .CreateTruck ();
            Console .WriteLine ( " create: "   + truck.getType ());


               factory = CarFactory .GetCarFactory ( 2 );
               ModelBus modelbus  =  (ModelBus)factory.CreateBus();
               Console.WriteLine( " create: "   +  modelbus.getType());
            ModelTruck modelTruck =  (ModelTruck)factory.CreateTruck();
            Console.WriteLine( " create: "   +  modelTruck.getType());
            Console.ReadLine();
        }
    }
}