装饰者模式

装饰者模式的定义：

装饰者(decorator)模式能够在不改变对象自身的基础上，在程序运行期间给对像动态的添加职责。与继承相比，装饰者是一种更轻便灵活的做法。

装饰者模式的特点：

可以动态的给某个对象添加额外的职责，而不会影响从这个类中派生的其它对象；

继承的一些缺点：

1. 继承会导致超类和子类之间存在强耦合性，当超类改变时，子类也会随之改变；
2. 超类的内部细节对于子类是可见的，继承常常被认为破坏了封装性；
3. 
   
4. 装饰者模式，Decorator Pattern。在不改变原类和继承的情况下动态扩展对象功能，通过包装一个对象来实现一个新的具有原对象相同接口的新的对象。
   
   

   装饰者模式特点：

       1. 不修改原对象的原本结构来进行功能添加。
       2. 装饰对象和原对象具有相同的接口，可以使客户以与原对象相同的方式使用装饰对象。
       3. 装饰对象中包含原对象的引用，即装饰对象为真正的原对象在此包装的对象。
   
   装饰者模式可以为对象添加功能从而代替了编写大量子类的情况。
       以JS设计模式实例为例，首先自行车商店有4种类型自行车：
   
   
   1. var ABicycle = function(){ ... };
      
   2. var BBicycle = function(){ ... };
      
   3. var CBicycle = function(){ ... };
      
   4. var DBicycle = function(){ ... };
   
       当自行车商店需要为每类自行车推出附加功能或者配件，比如前灯，车篮，改色等的时候，其最基本的方式就是为每一种组合创建一个子类，如有铃铛的A类车，黄色的B类车，有车篮的C类车等等，
   
   
   1. var ABicycleWithBell = function(){ ... };
      
   2. var BBicycleWithColorYellow = function(){ ... };
      
   3. var CBicycleWithColorBule = function(){ ... };
      
   4. ...
   
       的确，就犹如你第一眼看到的感觉一样，这搞法果断不靠谱，n种配置，到最后就会生成4n+4种类（包括原始的4个父类），那是决然不可取的。
   
       当然我们可能的第一想法便是可以将颜色，车篮什么的设为实例属性，在类中由传递的参数进行控制生成，这样的确不错没什么问题，不过对于一些功能上的扩展可能就心有余而力不足了，比如自行车添加变速功能，刹车加强功能，防盗功能等，那么对于添加这些功能使用装饰者模式则更为简便了（如果说将更能内置于类中，再由传参进行处理，在功能较多的情况下显然也比较不靠谱）。
   
       首先需要一个基础自行车A的类
       
   
   1. function ABicycle(){ }
      
   2. ABicycle.prototype = {
      
   3.     wash : function(){ },
      
   4.     ride : function(){ },
      
   5.     getPrice : function(){ 
      
   6.         return 999; 
      
   7.     }
      
   8. }
   
       接下来就是给自行车装上铃铛，响铃的功能：
       最简单的应该就是直接包装对象实例：
   
   
   1. function bicycleBell( bicycle ){
      
   2.     var price= bicycle.getPrice();
      
   3. 
      
   4.     bicycle.bell = function(){
      
   5.         console.log("ding! ding! ding!");
      
   6.     };
      
   7. 
      
   8.     bicycle.getPrice = function(){
      
   9.             return price + 100;
      
   10.     };
       
   11.     return bicycle;
       
   12. }
   
       那么使用
   
   
   1. var bicycleA = new ABicycle();
      
   2. bicycleA = bicycleBell( bicycleA );
   
       如果是下面这种形式
   
   
   1. bicycle.getPrice = function(){
      
   2.      return bicycle.getPrice() + 100;
      
   3. };
   
       这种形式当然就会导致无限循环调用~
   
       的确这种包装方法不是将对象再次包装成构造函数，仅仅只是调整实例对象，既方便又简单，不过对于类似getPrice方法这种返回常量数据结果的倒是问题也不大，可以使用如上面闭包形式的方式来保存。
   但如果对于其功能的在包装需要调用，再用闭包形式来先进行原始方法的保存，就会赶脚很繁琐不变。
   
   那么可以来看一下下面这种装饰方式：
   
   
   1. function BicycleBell( bicycle ){
      
   2.     this.bicycle = bicycle;
      
   3. }
      
   4. 
      
   5. BicycleBell.prototype = {
      
   6.     wash : function(){ 
      
   7.         return this.bicycle.wash();
      
   8.     },
      
   9.     ride : function(){
      
   10.         return this.bicycle.ride();
       
   11.     },
       
   12.     getPrice : function(){ 
       
   13.         return this.bicycle.ride() + 100; 
       
   14.     },
       
   15.     bell : function(){
       
   16.         console.log("ding! ding! ding!");
       
   17.     }
       
   18. }
   
       包装实例，再次模拟原始类，将实例作为参数包装，提供与原始类一样的接口。这种方式很好的解决了对于某些需要修改并且依赖原始该方法的方法生成形式。当然其也有自己的缺点，这个装饰者太过于繁琐，所有的，比如加速，切换颜色，车篮什么的装饰者每一个都必须如此形式的话势必代码有点杂乱多。
   
       那么，提取出来吧
       首先需要有一个继承的方法，并且有指向父类的prototype
   
   
   1. function extend( subClass, superClass ){
      
   2.     var F = function(){};
      
   3.     F.prototype = superClass.prototype;
      
   4.     subClass.prototype = new F();
      
   5.     subClass.prototype.constructor = subClass;
      
   6.     
      
   7.     // 此处指向superClass的prototype 比直接保存superClass使用更为方便
      
   8.     subClass.superclass = superClass.prototype;
      
   9.     if( superClass.prototype.constructor === Object.prototype.constructor ){
      
   10.         superClass.prototype.constructor = superClass;
       
   11.     }
       
   12. }
   
       再来一个各个装饰者可以依赖继承的中间装饰者：
   
   
   1. function BicycleDecorator( bicycle ){
      
   2.     this.bicycle = bicycle;
      
   3. }
      
   4. BicycleDecorator.prototype = {
      
   5.     wash : function(){ 
      
   6.         return this.bicycle.wash();
      
   7.     },
      
   8.     ride : function(){
      
   9.         return this.bicycle.ride();
      
   10.     },
       
   11.     getPrice : function(){ 
       
   12.         return this.bicycle.ride(); 
       
   13.     }
       
   14. }
   
       然后么很巧妙的使用extend
   
   
   1. var BicycleBell = function( bicycle ){
      
   2.     // 继承 BicycleDecorator 内部 this定义的数据或者方法
      
   3.     BicycleBell.superclass.constructor.call( this, bicycle );
      
   4. }
      
   5. // 继承 BicycleDecorator.prototype 并且添加 BicycleBell.superclass 指向 BicycleDecorator.prototype
      
   6. extend( BicycleBell, BicycleDecorator );
      
   7. // 添加或者修改
      
   8. BicycleBell.prototype.bell = function(){
      
   9.     console.log("ding! ding! ding!");
      
   10. }
       
   11. BicycleBell.prototype.getPrice = function(){
       
   12.     return this.bicycle.getPrice() + 100;
       
   13. }
   
       一样的方式进行实例包装使用
   
   
   1. var bicycleA = new ABicycle();
      
   2. bicycleA = new BicycleBell( bicycleA );
   
       上述方式就是一种较为不错的装饰者模式形式，更完善一些可能需要对BicycleDecorator，以及BicycleDecorator.prototype对象定义时使用对最初类遍历方式来获取各个原有接口。
   
   当然对于这几种方式可以按需进行使用，有针对性的处理才是最有方案。
   
5. 原地址：http://blog.chinaunix.net/uid-26672038-id-4364155.html