在面向对象编程中，类B可以继承自另外一个类A。我们将A称为父类（superclass），将B称为子类（subclass）。B的实例从A继承了所有的实例方法。类B可以定义自己的实例方法，有些方法可以重载类A中的同名方法，如果B的方法重载了A中的方法，B中的重载方法可能会调用A中的重载方法，这种做法称为“方法链”（method chaining）。同样，子类的构造函数B()有时需要调用父类的构造函数A()，这种做法称为“构造函数链”（constructor chaining）。子类还可以有子类，当涉及类的层次结构时，往往需要定义抽象类（abstract class）。抽象类中定义的方法没有实现。抽象类中的抽象方法是在抽象类的具体子类中实现的。
在JavaScript中创建子类的关键之处在于，采用合适的方法对原型对象进行初始化。如果类B继承自类A，B.prototype必须是A.prototype的后代。B的实例继承自B.prototype，后者同样也继承自A.prototype。此外还会介绍类继承的替代方案：“组合”（composition）。
-
定义子类
JavaScript的对象可以从类的原型对象中继承属性（通常继承的是方法）。如果O是类B的实例，B是A的子类，那么O也一定从A中继承了属性。为此，首先要确保B的原型对象继承自A的原型对象。通过inherit()函数，可以这样来实现：
B.prototype=inherit(A.prototype);//子类派生自父类
B.prototype.constructor=B;//重载继承来的constructor属性这两行代码是在JavaScript中创建子类的关键。如果不这样做，原型对象仅仅是一个普通对象，它只继承自Object.prototype，这意味着你的类和所有的类一样是Object的子类。如果将这两行代码添加至defineClass()函数中，可以将它变成例9-11中的defineSubclass()函数和Function.prototype.extend()方法：
例9-11：定义子类
//用一个简单的函数创建简单的子类
function defineSubclass(superclass,//父类的构造函数
constructor,//新的子类的构造函数
methods,//实例方法:复制至原型中
statics)//类属性:复制至构造函数中
{
//建立子类的原型对象
constructor.prototype=inherit(superclass.prototype);
constructor.prototype.constructor=constructor;//像对常规类一样复制方法和类属性
if(methods)extend(constructor.prototype,methods);
if(statics)extend(constructor,statics);//返回这个类
return constructor;
}
//也可以通过父类构造函数的方法来做到这一点
Function.prototype.extend=function(constructor,methods,statics){
return defineSubclass(this,constructor,methods,statics);
};例9-12展示了不使用defineSubclass()函数如何“手动”实现子类。这里定义了Set的子类SingletonSet。SingletonSet是一个特殊的集合，它是只读的，而且含有单独的常量成员。
例9-12：SingletonSet:一个简单的子类
//构造函数
function SingletonSet(member){
this.member=member;//记住集合中这个唯一的成员
}
//创建一个原型对象，这个原型对象继承自Set的原型
SingletonSet.prototype=inherit(Set.prototype);//给原型添加属性
//如果有同名的属性就覆盖Set.prototype中的同名属性
extend(SingletonSet.prototype,{//设置合适的constructor属性
constructor:SingletonSet,//这个集合是只读的：调用add()和remove()都会报错
add:function(){throw"read-only set";},
remove:function(){throw"read-only set";},//SingletonSet的实例中永远只有一个元素
size:function(){return 1;},//这个方法只调用一次，传入这个集合的唯一成员
foreach:function(f,context){f.call(context,this.member);},//contains()方法非常简单：
只须检查传入的值是否匹配这个集合唯一的成员即可
contains:function(x){return x===this.member;}
});这里的SingletonSet类是一个比较简单的实现，它包含5个简单的方法定义。它实现了5个核心的Set方法，但从它的父类中继承了toString()、toArray()和equals()方法。定义子类就是为了继承这些方法。比如，Set类的equals()方法用来对Set实例进行比较，只要Set的实例包含size()和foreach()方法，就可以通过equals()比较。因为SingletonSet是Set的子类，所以它自动继承了equals()的实现，不用再实现一次。当然，如果想要最简单的实现方式，那么给SingletonSet类定义它自己的equals()版本会更高效一些：
SingletonSet.prototype.equals=function(that){
return that instanceof Set＆＆that.size()==1＆＆that.contains(this.member);
};需要注意的是，SingletonSet不是将Set中的方法列表静态地借用过来，而是动态地从Set类继承方法。如果给Set.prototype添加新的方法，Set和SingletonSet的所有实例就会立即拥有这个方法（假定SingletonSet没有定义与之同名的方法）。
-
构造函数和方法链
最后一节的SingletonSet类定义了全新的集合实现，而且将它继承自其父类的核心方法全部替换。然而定义子类时，我们往往希望对父类的行为进行修改或扩充，而不是完全替换掉它们。为了做到这一点，构造函数和子类的方法需要调用或链接到父类构造函数和父类方法。
例9-13对此做了展示。它定义了Set的子类NonNullSet，它不允许null和undefined作为它的成员。为了使用这种方式对成员做限制，NonNullSet需要在其add()方法中对null和undefined值做检测。但它需要完全重新实现一个add()方法，因此它调用了父类中的这个方法。注意，NonNullSet()构造函数同样不需要重新实现，它只须将它的参数传入父类构造函数（作为函数来调用它，而不是通过构造函数来调用），通过父类的构造函数来初始化新创建的对象。
例9-13：在子类中调用父类的构造函数和方法
/*
*NonNullSet是Set的子类，它的成员不能是null和undefined
*/
function NonNullSet(){//仅链接到父类
//作为普通函数调用父类的构造函数来初始化通过该构造函数调用创建的对象
Set.apply(this,arguments);
}
//将NonNullSet设置为Set的子类
NonNullSet.prototype=inherit(Set.prototype);
NonNullSet.prototype.constructor=NonNullSet;//为了将null和undefined排除在外，只须重写add()方法
NonNullSet.prototype.add=function(){//检查参数是不是null或undefined
for(var i=0;i＜arguments.length;i++)
if(arguments[i]==null)
throw new Error("Can't add null or undefined to a NonNullSet");//调用父类的add()方法以执行
实际插入操作
return Set.prototype.add.apply(this,arguments);
};让我们将这个非null集合的概念推而广之，称为“过滤后的集合”，这个集合中的成员必须首先传入一个过滤函数再执行添加操作。为此，定义一个类工厂函数（类似例9-7中的enumeration()函数），传入一个过滤函数，返回一个新的Set子类。实际上，可以对此做进一步的通用化的处理，定义一个可以接收两个参数的类工厂：子类和用于add()方法的过滤函数。这个工厂方法称为filteredsetSubclass()，并通过这样的代码来使用它：
//定义一个只能保存字符串的"集合"类
var StringSet=filteredSetSubclass(Set,function(x){return typeof x==="string";});//这个集合
类的成员不能是null、undefined或函数
var MySet=filteredSetSubclass(NonNullSet,function(x){return typeof x!=="function";});例9-14是这个类工厂函数的实现代码。注意，这个例子中的方法链和构造函数链和NonNullset中的实现是一样的。
例9-14：类工厂和方法链
/*
*这个函数返回具体Set类的子类
*并重写该类的add()方法用以对添加的元素做特殊的过滤
*/
function filteredSetSubclass(superclass,filter){
var constructor=function(){//子类构造函数
superclass.apply(this,arguments);//调用父类构造函数
};
var proto=constructor.prototype=inherit(superclass.prototype);
proto.constructor=constructor;
proto.add=function(){//在添加任何成员之前首先使用过滤器将所有参数进行过滤
for(var i=0;i＜arguments.length;i++){
var v=arguments[i];
if(!filter(v))throw("value"+v+"rejected by filter");
}
//调用父类的add()方法
superclass.prototype.add.apply(this,arguments);
};
return constructor;
}例9-14中一个比较有趣的事情是，用一个函数将创建子类的代码包装起来，这样就可以在构造函数和方法链中使用父类的参数，而不是通过写死某个父类的名字来使用它的参数。也就是说如果想修改父类，只须修改一处代码即可，而不必对每个用到父类类名的地方都做修改。已经有充足的理由证明这种技术的可行性，即使在不是定义类工厂的场景中，这种技术也是值得提倡使用的。比如，可以这样使用包装函数和例9-11的Function.prototype.extend()方法来重写NonNullSet：
var NonNullSet=(function(){//定义并立即调用这个函数
var superclass=Set;//仅指定父类
return superclass.extend(
function(){superclass.apply(this,arguments);},//构造函数
{//方法
add:function(){//检查参数是否是null或undefined
for(var i=0;i＜arguments.length;i++)
if(arguments[i]==null)
throw new Error("Can't add null or undefined");//调用父类的add()方法以执行实际插入操作
return superclass.prototype.add.apply(this,arguments);
}
});
}());最后，值得强调的是，类似这种创建类工厂的能力是JavaScript语言动态特性的一个体现，类工厂是一种非常强大和有用的特性，这在Java和C++等语言中是没有的。
-
组合vs子类
定义的集合可以根据特定的标准对集合成员做限制，而且使用了子类的技术来实现这种功能，所创建的自定义子类使用了特定的过滤函数来对集合中的成员做限制。父类和过滤函数的每个组合都需要创建一个新的类。
然而还有另一种更好的方法来完成这种需求，即面向对象编程中一条广为人知的设计原则：“组合优于继承”。这样，可以利用组合的原理定义一个新的集合实现，它“包装”了另外一个集合对象，在将受限制的成员过滤掉之后会用到这个（包装的）集合对象。例9-15展示了其工作原理：
例9-15：使用组合代替继承的集合的实现
/*
*实现一个FilteredSet，它包装某个指定的"集合"对象，
*并对传入add()方法的值应用了某种指定的过滤器
*"范围"类中其他所有的核心方法延续到包装后的实例中
*/
var FilteredSet=Set.extend(
function FilteredSet(set,filter){//构造函数
this.set=set;
this.filter=filter;
},
{//实例方法
add:function(){//如果已有过滤器，直接使用它
if(this.filter){
for(var i=0;i＜arguments.length;i++){
var v=arguments[i];
if(!this.filter(v))
throw new Error("FilteredSet:value"+v+"rejected by filter");
}
}
//调用set中的add()方法
this.set.add.apply(this.set,arguments);
return this;
},//剩下的方法都保持不变
remove:function(){
this.set.remove.apply(this.set,arguments);
return this;
},
contains:function(v){return this.set.contains(v);},
size:function(){return this.set.size();},
foreach:function(f,c){this.set.foreach(f,c);}
});
在这个例子中使用组合的一个好处是，只须创建一个单独的FilteredSet子类即可。可以利用这个类的实例来创建任意带有成员限制的集合实例。比如，不用上文中定义的NonNullSet类，可以这样做：
var s=new FilteredSet(new Set(),function(x){return x!==null;});
甚至还可以对已经过滤后的集合进行过滤：
var t=new FilteredSet(s,{function(x){return!(x instanceof Set);}};
-
类的层次结构和抽象类
之前给出了“组合优于继承”的原则，但为了将这条原则阐述清楚，创建了Set的子类。这样做的原因是最终得到的类是Set的实例，它会从Set继承有用的辅助方法，比如toString()和equals()。尽管这是一个很实际的原因，但不用创建类似Set类这种具体类的子类也可以很好的用组合来实现“范围”。例9-12中的SingletonSet类可以有另外一种类似的实现，这个类还是继承自Set，因此它可以继承很多辅助方法，但它的实现和其父类的实现完全不一样。SingletonSet并不是Set类的专用版本，而是完全不同的另一种Set。在类层次结构中SingletonSet和Set应当是兄弟的关系，而非父子关系。
不管是在经典的面向对象编程语言中还是在JavaScript中，通行的解决办法是“从实现中抽离出接口”。假定定义了一个AbstractSet类，其中定义了一些辅助方法比如toString()，但并没有实现诸如foreach()的核心方法。这样，实现的Set、SingletonSet和FilteredSet都是这个抽象类的子类，FilteredSet和SingletonSet都不必再实现为某个不相关的类的子类了。
例9-16在这个思路上更进一步，定义了一个层次结构的抽象的集合类。AbstractSet只定义了一个抽象方法：contains()。任何类只要“声称”自己是一个表示范围的类，就必须至少定义这个contains()方法。然后，定义AbstractSet的子类AbstractEnumerableSet。这个类增加了抽象的size()和foreach()方法，而且定义了一些有用的非抽象方法（toString()、toArray()、equals()等），AbstractEnumerableSet并没有定义add()和remove()方法，它只代表只读集合。SingletonSet可以实现为非抽象子类。最后，定义了AbstractEnumerableSet的子类AbstractWritableSet。这个final抽象集合定义了抽象方法add()和remove()，并实现了诸如union()和intersection()等非具体方法，这两个方法调用了add()和remove()。AbstractWritableSet是Set和FilteredSet类相应的父类。但这个例子中并没有实现它，而是实现了一个新的名叫ArraySet的非抽象类。
例9-16中的代码很长，但还是应当完整地阅读一遍。注意这里用到了Function.prototype.extend()作为创建子类的快捷方式。
例9-16：抽象类和非抽象Set类的层次结构
//这个函数可以用做任何抽象方法，非常方便
function abstractmethod(){throw new Error("abstract method");}/*
*AbstractSet类定义了一个抽象方法：contains()
*/
function AbstractSet(){throw new Error("Can't instantiate abstract classes");}
AbstractSet.prototype.contains=abstractmethod;/*
*NotSet是AbstractSet的一个非抽象子类
*所有不在其他集合中的成员都在这个集合中
*因为它是在其他集合是不可写的条件下定义的
*同时由于它的成员是无限个，因此它是不可枚举的
*我们只能用它来检测元素成员的归属情况
*注意，我们使用了Function.prototype.extend()方法来定义这个子类
*/
var NotSet=AbstractSet.extend(
function NotSet(set){this.set=set;},
{
contains:function(x){return!this.set.contains(x);},
toString:function(x){return"～"+this.set.toString();},
equals:function(that){
return that instanceof NotSet＆＆this.set.equals(that.set);
}
}
);/*
*AbstractEnumerableSet是AbstractSet的一个抽象子类
*它定义了抽象方法size()和foreach()
*然后实现了非抽象方法isEmpty()、toArray()、to[Locale]String()和equals()方法
*子类实现了contains()、size()和foreach()，这三个方法可以很轻易地调用这5个非抽象方法
*/
var AbstractEnumerableSet=AbstractSet.extend(
function(){throw new Error("Can't instantiate abstract classes");},
{
size:abstractmethod,
foreach:abstractmethod,
isEmpty:function(){return this.size()==0;},
toString:function(){
var s="{",i=0;
this.foreach(function(v){
if(i++＞0)s+=",";
s+=v;
});
return s+"}";
},
toLocaleString:function(){
var s="{",i=0;
this.foreach(function(v){
if(i++＞0)s+=",";
if(v==null)s+=v;//null和undefined
else s+=v.toLocaleString();//其他的情况
});
return s+"}";
},
toArray:function(){
var a=[];
this.foreach(function(v){a.push(v);});
return a;
},
equals:function(that){
if(!(that instanceof AbstractEnumerableSet))return false;//如果它们的大小不同，则它们不相等
if(this.size()!=that.size())return false;//检查每一个元素是否也在that中
try{
this.foreach(function(v){if(!that.contains(v))throw false;});
return true;//所有的元素都匹配:集合相等
}catch(x){
if(x===false)return false;//集合不相等
throw x;//发生了其他的异常：重新抛出异常
}
}
});/*
*SingletonSet是AbstractEnumerableSet的非抽象子类
*singleton集合是只读的，它只包含一个成员
*/
var SingletonSet=AbstractEnumerableSet.extend(
function SingletonSet(member){this.member=member;},
{
contains:function(x){return x===this.member;},
size:function(){return 1;},
foreach:function(f,ctx){f.call(ctx,this.member);}
}
);/*
*AbstractWritableSet是AbstractEnumerableSet的抽象子类
*它定义了抽象方法add()和remove()
*然后实现了非抽象方法union()、intersection()和difference()
*/
var AbstractWritableSet=AbstractEnumerableSet.extend(
function(){throw new Error("Can't instantiate abstract classes");},
{
add:abstractmethod,
remove:abstractmethod,
union:function(that){
var self=this;
that.foreach(function(v){self.add(v);});
return this;
},
intersection:function(that){
var self=this;
this.foreach(function(v){if(!that.contains(v))self.remove(v);});
return this;
},
difference:function(that){
var self=this;
that.foreach(function(v){self.remove(v);});
return this;
}
});/*
*ArraySet是AbstractWritableSet的非抽象子类
*它以数组的形式表示集合中的元素
*对于它的contains()方法使用了数组的线性查找
*因为contains()方法的算法复杂度是O(n)而不是O(1)
*它非常适用于相对小型的集合，注意，这里的实现用到了ES5的数组方法indexOf()和forEach()
*/
var ArraySet=AbstractWritableSet.extend(
function ArraySet(){
this.values=[];
this.add.apply(this,arguments);
},
{
contains:function(v){return this.values.indexOf(v)!=-1;},
size:function(){return this.values.length;},
foreach:function(f,c){this.values.forEach(f,c);},
add:function(){
for(var i=0;i＜arguments.length;i++){
var arg=arguments[i];
if(!this.contains(arg))this.values.push(arg);
}
return this;
},
remove:function(){
for(var i=0;i＜arguments.length;i++){
var p=this.values.indexOf(arguments[i]);
if(p==-1)continue;
this.values.splice(p,1);
}
return this;
}
}
);
扫一扫
1464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
