function class1() { }
function class2() { }
class2.prototype = class1.prototype;
class2.moreProperty1 = "class 2 additional string";
class2.moreMethod1 = function() { alert("class 2 additional method"); }
/*
这样,首先是class2具有了和class1 一样的prototype,不考虑构造函数,两个类是等价的。
随后,又通过prototype给class2赋予了两个额外的方法。所以class2是在class1的基础上
增加了属性和方法,这就实现了类的继承。
*/
function test() {
var obj = new class2();
// JavaScript提供了instanceof 操作符来判断一个对象是否是某个类的实例
alert(obj instanceof class2); // true
alert(obj instanceof class1); // ?
}
//定义class1
function class1() {
//构造函数
}
//定义class1 的成员
class1.prototype = {
m1: function() { // 方法1
alert("class1 method1");
}
}
//定义class2
function class2() {
//构造函数
}
//让class2 继承于class1
class2.prototype = class1.prototype;
//给class2 重复定义方法method
class2.prototype.method = function() {
alert("whose method2? class1 or class2");
}
//创建两个类的实例
var obj1 = new class1();
var obj2 = new class2();
function test() {
//分别调用两个对象的method 方法
obj1.method();
obj2.method();
}
由此可见,当对class2 进行prototype 的改变时,class1的prototype也随之改变,即使对class2 的prototype 增减一些成员,class1的成员也随之改变。所以class1 和class2 仅仅是构造函数不同的两个类,它们保持着相同的成员定义。说到这里,相信读者已经发现了其中的奥妙:class1 和class2 的prototype 是完全相同的,是对同一个对象的引用。其实从这条赋值语句就可以看出来:
//让class2 继承于class1
class2.prototype=class1.prototype;
在js中,除了基本的数据类型(数字、字符串、布尔类型等),所有的赋值以及函 数参数都是引用传递,而不是值传递。所以上面的语句仅仅是让class2 的prototype 对象引用class1 的prototype,造成了类成员定义始终保持一致的效果。从这里也看到了instanceof 操作符的执行机制,它就是判断一个对象是否是一个prototype 的实例,因为这里的obj1 和obj2 都是对应于同一个prototype,所以它们instanceof 的结果都是相同的。由此可见,使用prototype 引用拷贝实现继承不是一种正确的办法。但在要求不严格的情况下,却也是一种合理的方法,唯一的约束是不允许类成员的覆盖定义(这里其实也是js的灵活性的体现)。其实,我们完全可以利用反射机制和prototype 来实现js正确的类继承:
function class1() {
//构造函数
}
class1.prototype = {
method: function() {
alert("method1");
},
method2: function() {
alert("method2");
}
}
function class2() {
//构造函数
}
//让class2 继承于class1
for (var p in class1.prototype) {
class2.prototype[p] = class1.prototype[p]; // 利用反射机制和prototype实现继承
}
//覆盖定义class1中的method 方法
class2.prototype.method = function() {
alert("class2 new method1");
}
//创建两个类的实例
var obj1 = new class1();
var obj2 = new class2();
function test() {
//分别调用两个对象的method 方法
obj1.method();
obj2.method();
//分别调用两个对象的method2 方法
obj1.method2();
obj2.method2();
}
//为类添加静态方法inherit表示继承于某类
Function.prototype.inherit = function(baseClass) {
for (var p in baseClass.prototype) {
this.prototype[p] = baseClass.prototype[p];
}
}
function class1() {
//构造函数
}
class1.prototype = {
method: function() {
alert("method1");
},
method2: function() {
alert("method2");
}
}
function class2() {
//构造函数
}
//让class2 继承于class1
//for (var p in class1.prototype) {
// class2.prototype[p] = class1.prototype[p]; // 利用反射机制和prototype实现继承
//}
class2.inherit(class1); // 等价于上面注释掉的那一个for循环
//覆盖定义class1中的method 方法
class2.prototype.method = function() {
alert("class2 new method1");
}
//创建两个类的实例
var obj1 = new class1();
var obj2 = new class2();
function test() {
//分别调用两个对象的method 方法
obj1.method();
obj2.method();
//分别调用两个对象的method2 方法
obj1.method2();
obj2.method2();
}
上面的代码使逻辑变的更加清楚,也更容易理解。通过这种方法实现的继承,有一个缺点,就是在class2 中添加类成员定义时,不能给prototype 直接赋值,而只能对其属性进行赋值,例如不能为:
class2.prototype={
//成员定义
}
而只能为:
class2.prototype.propertyName=someValue;
class2.prototype.methodName=function(){
//语句
}
由此可见,这样实现继承仍然要以牺牲一定的代码可读性为代价。有没有“不仅基类可以用对象直接赋值给property,而且在派生类中也可以同样实现,使代码逻辑更加清晰,也更能体现面向对象的语言特点”的js继承方式?引号里的说法是多么的诱人啊,继续学习去了。