Javascript 继承机制和构造方法链实现

/** 
 * 扩展函数 
 * @param target 扩展对象 
 * @param params 扩展参数 
 */  
function extend(target, params) {  
    if (!target) {  
        target = {};  
    }  
    for (var prop in params) {  
        target[prop] = params[prop];  
    }     
    return target;  
}

/** 
 * 继承函数 
 * @param SuperClass 父类 
 * @param overrides 重写方法 
 */  
function extendClass(SuperClass, overrides) {  
    var SubClass = function() {  
                // 自动调用构造函数  
        this.initialize.apply(this, arguments);  
    };  
      
    SubClass.prototype = new SuperClass();  
      
    extend(SubClass.prototype, overrides);  
      
    SubClass.superclass = SuperClass;  
      
    return SubClass;  
}

var Animal = extendClass(Object, {  
    initialize: function(name){   
        this.name = name;  
    },  
      
    showName: function(){    
        alert(this.name);    
    }  
});  
  
var Cat = extendClass(Animal, {  
    initialize: function(name) {  
                // 调用父类构造函数  
        Cat.superclass.prototype.initialize.call(this, name);  
    }  
});  
  
var BlackCat = extendClass(Cat, {  
    initialize: function(name, type) {  
                // 调用父类构造函数  
        BlackCat.superclass.prototype.initialize.call(this, name);  
        this.type = type;  
    },  
    showType: function() {  
        alert(this.type);  
    },  
    showName: function() {  
        alert(this.name + ":" + this.type);  
    }  
});  
  
  
var cat = new Cat("cat name");  
// 继承方法  
cat.showName();  
  
// true  
alert(cat instanceof Animal);  
  
// true  
alert(cat instanceof Cat);  
  
// false  
alert(cat instanceof BlackCat);  
  
var blackCat = new BlackCat("123", "black");  
  
// 方法重写  
blackCat.showName();  
  
// 自有方法  
blackCat.showType();  
  
// true  
alert(blackCat instanceof Animal);  
  
// true  
alert(blackCat instanceof Cat);  
  
// true  
alert(blackCat instanceof BlackCat);