子类中定义的实例方法是不能访问父类中定义的私有实例成员的

首先创建一个父类的实例化对象,然后将该对象赋给子类的 prototype 属性。
这样,父类中的所有公有实例成员都会被子类继承。并且用 instanceof
运算符判断时,子类的实例化对象既属于子类,也属于父类。
然后将子类本身赋值给它的 prototype 的 constructor 属性。
这一步是为了保证在查看子类的实例化对象的 constructor
属性时,看到的是子类的定义,而不是其父类的定义。 接下来,通过对
o.method1()
调用的结果我们会看到,子类继承来的公有实例方法中,如果调用了私有实例字段或者私有实例方法,则所调用的这些私有实例成员是属于父类的。
同样,通过对 o.method2()
调用的结果我们看到,子类中定义的实例方法,如果调用了私有实例字段或者私有实例方法,则所调用的这些私有实例成员是属于子类的。
通过对 o.method()
调用的结果我们看到,定义在父类原型上的方法,会被子类继承。 通过对
o.method3()
调用的结果我们看到,子类中定义的实例方法是不能访问父类中定义的私有实例成员的。
最后,通过对 subClass.staticMethod()
调用的结果我们看到,静态成员是不会被继承的。 2.4 调用继承法
调用继承的本质是,在子类的构造器中,让父类的构造器方法在子类的执行上下文上执行,父类构造器方法上所有通过
this
方式操作的内容实际上都都是操作的子类的实例化对象上的内容。因此,这种做法仅仅为了减少重复代码的编写。
复制代码 代码如下: function parentClass()
{ // private field var x = “I’m a parentClass field!”; // private method
function method1; alert(“I’m a parentClass method!”); } // public field
this.x = “I’m a parentClass object field子类中定义的实例方法是不能访问父类中定义的私有实例成员的。!”; // public method
this.method1 = function; alert; } } parentClass.prototype.method =
function () { alert(“I’m a parentClass prototype method!”); }
parentClass.staticMethod = function () { alert(“I’m a parentClass static
method!”); } function subClass() { // inherit parentClass.call; //
private field var x = “I’m a subClass field子类中定义的实例方法是不能访问父类中定义的私有实例成员的。子类中定义的实例方法是不能访问父类中定义的私有实例成员的。!”; // private method
function method2; alert(“I’m a subClass method!”); } // public field
this.x = “I’m a subClass object field!”; // public method this.method2 =
function; alert; } this.method3 = function; } } // test var o = new
subClass(); alert(o instanceof parentClass); // false alert(o instanceof
subClass); // true alert; // function subClass; // I’m a parentClass
fieldwww.602.net,! // I’m a subClass object field! // I’m a parentClass field! //
I’m a parentClass method! o.method2(); // I’m a subClass field! // I’m a
subClass object field! // I’m a subClass field! // I’m a subClass
method! o.method(); // Error!!! o.method3(); // Error!!!
subClass.staticMethod(); // Error!!!
上面这个例子很好的反映出了如何利用调用继承法来实现继承。
利用调用继承的关键只有一步操作: 就是在子类定义时,通过父类的 call
方法,将子类的 this 指针传入。使父类方法在子类上下文中执行。
这样,父类中的所有在父类内部通过 this
方式定义的公有实例成员都会被子类继承。 用 instanceof
运算符判断时,子类的实例化对象只属于子类,不属于父类。
查看子类的实例化对象的 constructor
属性时,看到的是子类的定义,不是其父类的定义。 接下来,通过对 o.method1
调用的结果跟原型继承法的调用结果是相同的,所说明的问题也是一样的,这里不再重复。
通过对 o.method()
调用的结果我们看到,定义在父类原型上的方法,不会被子类继承。 通过对
o.method3()
调用的结果我们看到,子类中定义的实例方法同样不能访问父类中定义的私有实例成员的。
最后,通过对 subClass.staticMethod()
调用的结果我们看到,静态成员同样不会被继承的。
最后,还有一点,在这个例子中没有体现出来,就是通过调用继承法,可以实现多继承。也就是说,一个子类可以从多个父类中继承通过
this 方式定义在父类内部的所有公有实例成员。
作为一种弱类型语言,javascript 提供了丰富的多态性,javascript
的多态性是其它强类型面向对象语言所不能比的。 多态 重载和覆盖
先来说明一下重载和覆盖的区别。重载的英文是 overload,覆盖的英文是
override。发现网上大多数人把 override
当成了重载,这个是不对的。重载和覆盖是有区别的。
重载的意思是,同一个名字的函数或方法可以有多个实现,他们依靠参数的类型和参数的个数来区分识别。
而覆盖的意思是,子类中可以定义与父类中同名,并且参数类型和个数也相同的方法,这些方法的定义后,在子类的实例化对象中,父类中继承的这些同名方法将被隐藏。
重载 javascript
中函数的参数是没有类型的,并且参数个数也是任意的,例如,尽管你可以定义一个:
复制代码 代码如下: function add { return
a + b; }
这样的函数,但是你仍然可以再调用它是带入任意多个参数,当然,参数类型也是任意的。至于是否出错,那是这个函数中所执行的内容来决定的,javascript
并不根据你指定的参数个数和参数类型来判断你调用的是哪个函数。
因此,要定义重载方法,就不能像强类型语言中那样做了。但是你仍然可以实现重载。就是通过函数的
arguments 属性。例如: 复制代码 代码如下:
function add() { var sum = 0; for (var i = 0; i < arguments.length;
i++) { sum += arguments[i]; } return sum; }
这样你就实现了任意多个参数加法函数的重载了。 当然,你还可以在函数中通过
instanceof 或者 constructor
来判断每个参数的类型,来决定后面执行什么操作,实现更为复杂的函数或方法重载。总之,javascript
的重载,是在函数中由用户自己通过操作 arguments 这个属性来实现的。 覆盖
实现覆盖也很容易,例如: 复制代码
代码如下: function parentClass() { this.method = function() { alert; } }
function subClass() { this.method = function() { alert; } }
subClass.prototype = new parentClass(); subClass.prototype.constructor =
subClass; var o = new subClass; 这样,子类中定义的 method
就覆盖了从父类中继承来的 method 方法了。
你可能会说,这样子覆盖是不错,但 java
中,覆盖的方法里面可以调用被覆盖的方法,在这里怎么实现呢?也很容易,而且比
java 中还要灵活,java 中限制,你只能在覆盖被覆盖方法的方法中才能使用
super
来调用次被覆盖的方法。我们不但可以实现这点,而且还可以让子类中所有的方法中都可以调用父类中被覆盖的方法。看下面的例子:
复制代码 代码如下: function parentClass()
{ this.method = function() { alert; } } function subClass() { var method
= this.method; this.method = function; alert; } } subClass.prototype =
new parentClass(); subClass.prototype.constructor = subClass; var o =
new subClass;
你会发现,原来这么简单,只要在定义覆盖方法前,定义一个私有变量,然后把父类中定义的将要被覆盖的方法赋给它,然后我们就可以在后面继续调用它了,而且这个是这个方法是私有的,对于子类的对象是不可见的。这样跟其它高级语言实现的覆盖就一致了。
最后需要注意,我们在覆盖方法中调用这个方法时,需要用 call
方法来改变执行上下文为
this,如果直接调用这个方法,执行上下文就会变成全局对象了。

发表评论

电子邮件地址不会被公开。 必填项已用*标注