Chinaunix首页 | 论坛 | 博客
  • 博客访问: 714742
  • 博文数量: 62
  • 博客积分: 526
  • 博客等级: 二等列兵
  • 技术积分: 2078
  • 用 户 组: 普通用户
  • 注册时间: 2012-02-04 20:41
  • 认证徽章:
个人简介

博客迁移至 freefe.cc

文章分类

全部博文(62)

分类: JavaScript

2013-11-26 19:17:37

   

    工厂方法模式(Factory method pattern)


    工厂方法模式(Factory method pattern)是一种实现“工厂”概念的面上对象设计模式。实质是定义一个创建对象的接口,但是让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。
    创建一个对象常常需要复杂的过程,所以不适合在一个复杂的对象中。创建对象可能会导致大量的重复代码,也可能提供不了足够级别的抽象。工厂方法模式通过定义一个单独的创建对象的方法来解决这些问题,由子类实现这个方法来创建具体类型的对象。

  1. //几个Button类
  2. class Button{/* ...*/}
  3. class WinButton extends Button{/* ...*/}
  4. class MacButton extends Button{/* ...*/}
  5.  
  6. //它们的工厂类
  7. interface ButtonFactory{
  8.     abstract Button createButton();
  9. }
  10. class WinButtonFactory implements ButtonFactory{
  11.     Button createButton(){
  12.         return new WinButton();
  13.     }
  14. }

  15. class MacButtonFactory implements ButtonFactory{
  16.     Button createButton(){
  17.         return new MacButton();
  18.     }
  19. }

    在JS中创建对象会习惯的使用 new 关键字和类构造函数(当然主要还是对象字面量),问题在于这样会导致两个类之间产生依赖性。
    工厂模式就是一种有助于消除两个类依赖性的模式。
    简单工厂模式:使用一个类(通常为单体)来生成实例。
    复杂工厂模式:使用子类来决定一个成员变量应该是哪个具体的类的实例。

实现1:简单工厂模式


    上 JS设计模式 上的实例, 对于自行车商店出售自行车:

  1. /* BicycleShop class */
  2. var BicycleShop = function(){};
  3. BicycleShop.prototype = {

  4.     sellBicycle : function( model ){
  5.         var bicycle;
  6.         switch( model ){
  7.             case "The Speedster":
  8.                 bicycle = new Speedster();
  9.                 break;
  10.             case "The Lowrider":
  11.                 bicycle = new Lowrider();
  12.                 break;
  13.             case "The Cruiser":
  14.             default:
  15.                 bicycle = new Cruiser();
  16.                 break;
  17.         }
  18.         return bicycle;
  19.     }
  20. }
    
    sellBicycle 方法根据所提供的自行车型号来进行自行车的实例创建。那么对于一家ABC店铺,需要Speedster车型我只需要
    var ABC = new BicycleShop();
    var myBike = ABC.sellBicycle("The Speedster");


    以上方式很管用,但是一旦说我需要添加一些自行车款式的时候我就必须修改 BicycleShop 的 switch 部分,那么只要是修改就有可能带来BUG。所以,将这部分生成实例的代码单独的提出来分工交给一个简单的工厂对象是一个很不错的方法。


  1. var BicycleFactory = {
  2.     createBicycle : function( model ){
  3.         var bicycle;
  4.         switch( model ){
  5.             case "The Speedster":
  6.                 bicycle = new Speedster();
  7.                 break;
  8.             case "The Lowrider":
  9.                 bicycle = new Lowrider();
  10.                 break;
  11.             case "The Cruiser":
  12.             default:
  13.                 bicycle = new Cruiser();
  14.                 break;
  15.         }
  16.         return bycicle;
  17.     }
  18. }

    BicycleFactory 是一个脱离于BicycleShop的单体。降低耦合度的效果显而易见。当需要添加新的类型的时候,不需要动 BicycleShop 只需修改工厂单体对象就可以。

  1. var BicycleShop = function(){};

  2. BicycleShop.prototype = {
  3.     sellBicycle : function( model ){
  4.         var bicycle = BicycleFactory.createBicycle(model);     
  5.         return bicycle;
  6.     }
  7. }
   
     以上就是一个很好的 简单工厂模式 的实例。该模式将成员对象的创建工作交给一个外部对象实现,该外部对象可以是一个简单的命名空间,也可以是一个类的实例。


实现2:工厂模式


    真正的工厂模式与简单工厂模式相比,主要区别就是它不是另外使用一个对象或者类来创建实例(自行车),而是使用一个子类。工厂是一个将其成员对象的实例化推迟到子类中进行的类。


    比如加入BicycleShop可以决定从那一家厂商进行进货,那么简单的一个BicycleFactory是不够了的,因为各个厂商会各自生产不同的Speedster,Lowrider,Cruiser等型号自行车,所以首先需要生成各自厂商的shop实例,不同厂商的shop实例拥有不同的生成几个型号自行车的方法。

    也就是相当于将自行车对象的实例化推迟到了shop实例中产生。
    基础:
    
  1. var BicycleShop = function(){}

  2. BicycleShop.prototype={
  3.     sellBicycle: function( model ){
  4.         var bicycle = this.createBicycle( model );
  5.         return bicycle;
  6.     },
  7.     createBicycle: function( model ){
  8.         throw new Error( " Unsupported " );
  9.     }
  10. }

    各自厂商:
    
  1. var AcmeBicycleShop = function(){};

  2. extend( AcmeBicycleShop , BicycleShop );
  3. AcmeBicycleShop.prototype.createBicycle = function( model ){
  4.     var bicycle;
  5.     switch( model ){
  6.         case "The Speedster":
  7.             bicycle = new AcmeSpeedster();
  8.             break;
  9.         case "The Lowrider":
  10.             bicycle = new AcmeLowrider();
  11.             break;
  12.         case "The Cruiser":
  13.         default:
  14.             bicycle = new AcmeCruiser();
  15.             break;
  16.     }
  17.     return bicycle;
  18. }

  19. var GeneralBicycleShop = function(){};

  20. extend( GeneralBicycleShop , BicycleShop );
  21. GeneralBicycleShop.prototype.createBicycle = function( model ){
  22.    ...
  23. }

    那么接下来就很简单 对于来自 Acme 进货的 

    var acmeShop = new AcmeBicycleShop();
    var newBicycle = acmeShop.sellBicycle("The Speedster");

    当然,你也可以对于外层生成的子类实例在使用简单工厂模式进行包装一下~对于添加其他厂商也很简单,在创建一个Bicycle的子类重新定义其createBicycle的工厂方法即可。


    工厂模式使用场合


    1. 动态实现
    例如自行车的例子,创建一些用不同方式实现统一接口的对象,那么可以使用一个工厂方法或者简单工厂对象来简化实现过程。选择可以是明确进行的也可以是隐含的。

    2. 节省设置开销
    如果对象要进行复杂的并且彼此相关的设置的时候,那么工厂模式可以很显著的减少每种对象的代码量。将特定的设置代码提取出来会使得代码有极大地提升。并且能优化结构便于维护。

    3. 用于许多小型对象组成一个大对象。

    4. 工厂模式之利
    主要好处就是可以消除对象间的耦合,通过使用工程方法而不是new关键字。将所有实例化的代码集中在一个位子防止代码重复。

    5. 工厂模式之弊
    大多数类最好使用new关键字和构造函数,可以让代码更加简单易读。而不必去查看工厂方法来知道。



阅读(18800) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册