传统的继承在JavaScript中的应用

  简单的意译,JavaScript仿照传统的继承方式进行继承(如:Java的继承方式)

  JavaScript是一种弱类型,面向对象的语言,正因为如此,它使用原型继承,而不是经典的继承。这些让使用传统的面向对象语言,如C++和Java的程序员很不能理解。 JavaScript的原型继承比传统的继承有着更强的表现力。


  不过要问,我们为什么关心继承呢?主要有两个原因:

  第一:类型的便利。我们想要的语言系统自动转化相似类的引用。强类型语言(如Java),类型系统要求对对象的引用要进行显示的类型转换,而对于弱类型的JavaScript中的对象引用不存在转换问题。

  第二:代码的重用。有一定数量的对象实现了相同的方法,或者一个对象与其他对象具有共同部分,其余都是给该对象增加或减少少量的方法,这时候就用继承来提取公共部分,这将是非常有用。而JavaScript的Prototype继承更加有用。


 下面是用JavaScript来模仿传统的继承。

 Java示例:类Parenizor


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Parenizor{
    private String value;
                                                                                                                                                                                                                                                                                           
    public Parenizor(value){
        this.value=value;
    }
                                                                                                                                                                                                                                                                                           
    public void setValue(value){
        this.value=value;
    }
                                                                                                                                                                                                                                                                                           
    public String getValue(){
        return this.value;
    }
                                                                                                                                                                                                                                                                                           
    public String toString(){
        return "Parenizor[value:"+value+"]";
    }
                                                                                                                                                                                                                                                                                           
}

 JavaScript示例:原型对象Parenizor

1
2
3
4
5
6
7
8
9
10
11
12
13
function Parenizor(value) {
    this.setValue(value);
}
Parenizor.method('setValue'function (value) {
    this.value = value;
    return this;
});
Parenizor.method('getValue'function () {
    return this.value;
});
Parenizor.method('toString'function () {
    return '(' this.getValue() + ')';
});

 上面JavaScript模仿的例子还不能使用,method是Function内置对象的方法,而该方法是用户自己为Function对象添加的原型方法。因此要添加如下方法,上面JavaScript模仿Java的类定义中的方法才能正常使用。

 Function.prototype.method方法如下:


1
2
3
4
Function.prototype.method = function (name, func) {
    this.prototype[name] = func;
    return this;
};

关于继承:再次扩充了函数,使它继承了父类的一个实例并将它用于一个新的原型,并且修改constructor部分,并将uber方法一并添加到这个原型中来了。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Function.method('inherits'function (parent) {
    this.prototype = new parent();
    var d = {},
        p = this.prototype;
    this.prototype.constructor = parent;
    this.method('uber'function uber(name) {
        if (!(name in d)) {
            d[name] = 0;
        }
        var f, r, t = d[name], v = parent.prototype;
        if (t) {
            while (t) {
                v = v.constructor.prototype;
                t -= 1;
            }
            f = v[name];
        else {
            f = p[name];
            if (f == this[name]) {
                f = v[name];
            }
        }
        d[name] += 1;
        r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
        d[name] -= 1;
        return r;
    });
    return this;
});

关于多继承:

使用函数的Prototype对象是可以实现多继承的,通过使用多个类来构造一个新类,不过这样的多重继承会很复杂和不易维护。


1
2
3
4
5
6
7
Function.method('swiss'function (parent) {
    for (var i = 1; i < arguments.length; i += 1) {
        var name = arguments[i];
        this.prototype[name] = parent.prototype[name];
    }
    return this;
});

   swiss方法中循环访问arguments数组中的元素。对于每一个名称,它从父级prototype中复制一个member到它的新类的prototype中去。

   使用方式:

 

1
ZParenizor.swiss(NumberValue, 'setValue''setRange');

  只需要为ZParenizor添加上需要的NumberValue的方法setValue和setRange.


译文末:

  传统意义上的对象是固化的,只有新建一个类才能添加对象的成员。但是在JavaScript中,对象是开放的,能够非常方便的添加成员。



本文转自 secondriver 51CTO博客,原文链接:http://blog.51cto.com/aiilive/1273037,如需转载请自行联系原作者

上一篇:MongoDB学习笔记(四)基本管理命令


下一篇:CRM系统业务的分析(1)