浅析JavaScript继承方式(1)(2)

这篇开始写几个工具函数实现类的扩展。每个工具函数都是针对特定的写类方式(习惯)。这篇按照构造函数方式写类：属性(字段)和方法都挂在this上。以下分别提供了个类，分别作为父类和子类。

//  父类Person  
function Person(nationality) {  
    this.nationality = nationality;  
    this.setNationality = function(n) {this.nationality=n;};  
    this.getNationality = function() {return this.nationality;};  
}  
 
// 类Man  
function Man(name) {  
    this.name = name;  
    this.setName = function(n){this.name=n;};  
    this.getName = function(){return this.name;};  
} 

继承工具函数一

/**  
 * @param {Function} subCls 子类  
 * @param {Function} superCls 父类  
 * @param {Object} param 父类构造参数  
 */ 
function extend(subCls,superCls,param) {  
    superCls.call(subCls.prototype,param);  
} 

使用如下

extend(Man,Person,'China');  
var m = new Man('jack');  
console.log(m.nationality);//China  
console.log(m.setNationality('Japan'));  
console.log(m.getNationality('Japan'));//Japan 

输出可以看到Man继承了Person的属性及所有方法。这种继承方式于java的很不一样哦，

class Animal {  
    int legs;     
    Animal(int l) {  
        legs = l;  
    }  
    int getLegs() {  
        return legs;  
    }  
}  
public class Person extends Animal{  
    //属性（字段）  
    String name;      
    //构造方法（函数）  
    Person(int legs, String name) {  
        super(legs);//调用父类构造器  
        this.name = name;  
    }     
    //方法  
    String getName() {  
        return this.name;  
    }  
    public static void main(String[] args) {  
          
        Person p = new Person(2,"jack");          
        System.out.println(p.legs);  
    }  
} 

Java中，子类Person在自身构造方法中调用父类构造方法super(legs)，创建对象的时候直接将父类构造参数legs:2传进去，不仅仅只传自己的name:jack。上面JavaScript继承是在extend时传父类构造参数(extend函数的第三个参数)，而不是在new Man时将父类构造参数传过去。好，模拟Java来实现下extend，这里巧妙的在子类上暂存了父类引用。

继承工具函数二

/**  
 * @param {Function} subCls  
 * @param {Function} superCls  
 */ 
function extend(subCls,superCls) {    
    subCls.supr = superCls;  
}  

还是以Person为父类，来实现子类Woman

function Woman(nationality,name) {  
    Woman.supr.call(this,nationality);//和java有点类似哦，在子类中调用父类构造器  
    this.name = name;  
    this.setName = function(n){this.name=n;};  
    this.getName = function(){return this.name;};  
}<br>extend(Woman,Person);<br> 

最后，创建对象的方式和java也类似，即new的时候同时将父类构造参数(nationality:Japan)传进去。

var w = new Woman('Japan','lily');  
console.log(w.nationality);//Japan  
w.setNationality('U.S.A');  
console.log(w.getNationality());//U.S.A 

继承工具函数三

/**  
 * @param {Function} subCls  
 * @param {Function} superCls  
 */ 
function extend(subCls,superCls) {  
    subCls.prototype = new superCls();    
} 

父类，按原型方式写，即属性和方法都挂在原型上。

/**  
 *  父类Person  
 */ 
function Person(){}  
Person.prototype.nationality = 'China';  
Person.prototype.getNationality = function() {return this.nationality;}  
Person.prototype.setNationality = function(n) { this.nationality = n;} 

子类继承与父类

function Man() {}  
extend(Man,Person); 

继承父类的属性和方法后，再添加子类自有属性，方法

Man.prototype.name = 'jack';  
Man.prototype.getName = function() { return this.name;}  
Man.prototype.setName = function(n) { this.name=n;} 

测试如下，

var m = new Man();  
console.log(m);  
console.log(m instanceof Person); 

可以看到这种写类方式，继承方式完全采用原型机制。