Javascript面向对象程序设计之三：多态

重载和覆盖

先来说明一下重载和覆盖的区别。重载的英文是 overload，覆盖的英文是 override。发现网上大多数人把 override 当成了重载，这个是不对的。重载和覆盖是有区别的。

重载的意思是，同一个名字的函数（注意这里包括函数）或方法可以有多个实现，他们依靠参数的类型和（或）参数的个数来区分识别。

覆盖的意思是，子类中可以定义与父类中同名，并且参数类型和个数也相同的方法，这些方法的定义后，在子类的实例化对象中，父类中继承的这些同名方法将被隐藏。

一.重载

javascript 中函数的参数是没有类型的，并且参数个数也是任意的，例如，尽管你可以定义一个：

 

1. function add(a, b) {  
2.     return a + b;  
3. }  

这样的函数，但是你仍然可以再调用它是带入任意多个参数，当然，参数类型也是任意的。至于是否出错，那是这个函数中所执行的内容来决

定的，javascript 并不根据你指定的参数个数和参数类型来判断你调用的是哪个函数。

因此，要定义重载方法，就不能像强类型语言中那样做了。但是你仍然可以实现重载。就是通过函数的 arguments 属性。例如：

 

 

1. function add() {  
2.     var sum = 0;  
3.     for (var i = 0; i < arguments.length; i++) {  
4.         sum += arguments[i];  
5.     }  
6.     return sum;  
7. }  

这样你就实现了任意多个参数加法函数的重载了。

当然，你还可以在函数中通过 instanceof 或者 constructor 来判断每个参数的类型，来决定后面执行什么操作，实现更为复杂的函数或方法重载。总之，javascript 的重载，是在函数中由用户自己通过操作 arguments 这个属性来实现的。

 

 

二.覆盖

实现覆盖也很容易，例如：

 

 

1. function parentClass() {  
2.     this.method = function() {  
3.         alert("parentClass method");  
4.     }  
5. }  
6. function subClass() {  
7.     this.method = function() {  
8.         alert("subClass method");  
9.     }  
10. }  
11. subClass.prototype = new parentClass();  
12. subClass.prototype.constructor = subClass;  
13.    
14. var o = new subClass();  
15. o.method();  

这样，子类中定义的 method 就覆盖了从父类中继承来的 method 方法了。

你可能会说，这样子覆盖是不错，但 java 中，覆盖的方法里面可以调用被覆盖的方法（父类的方法），在这里怎么实现呢？也很容易，而且

比 java 中还要灵活，java 中限制，你只能在覆盖被覆盖方法的方法中才能使用 super 来调用次被覆盖的方法。我们不但可以实现这点，而

且还可以让子类中所有的方法中都可以调用父类中被覆盖的方法。看下面的例子：

 

 

1. function parentClass() {  
2.     this.method = function() {  
3.         alert("parentClass method");  
4.     }  
5. }  
6. function subClass() {  
7.     var method = this.method;  
8.     this.method = function() {  
9.         method.call(this);  
10.         alert("subClass method");  
11.     }  
12. }  
13. subClass.prototype = new parentClass();  
14. subClass.prototype.constructor = subClass;  
15.    
16. var o = new subClass();  
17. o.method();  

你会发现，原来这么简单，只要在定义覆盖方法前，定义一个私有变量，然后把父类中定义的将要被覆盖的方法赋给它，然后我们就可以在后

面继续调用它了，而且这个是这个方法是私有的，对于子类的对象是不可见的。这样跟其它高级语言实现的覆盖就一致了。

最后需要注意，我们在覆盖方法中调用这个方法时，需要用 call 方法来改变执行上下文为 this（虽然在这个例子中没有必要），如果直接调

用这个方法，执行上下文就会变成全局对象了。