在每天敲点犀牛书：子类中，已经介绍了定义子类、构造函数和方法链这两部分的内容，今天开始敲关于子类的剩下两个部分的内容。
组合 vs 子类
面向对象编程中有一条广为人知的设计原则：组合优于继承。下面利用组合的原理定义一个新的集合实现。
/*
* 实现一个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); });
类的层次结构和抽象类
下面定义了一个层次结构的抽象的集合类，代码很长，但还是应该阅读一遍的。注意这里用到了Function.prototype.extend()作为创建子类的快捷方式。
// 这个函数可以用做任何抽象方法，非常方便
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.prototypr.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 AbstractWritableASet = 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 = AbstractWritableASet.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.valuse.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;
}
}
);
在这个抽象类和非抽象Set类的层次结构中，AbstractSet只定义了一个抽象方法：contains()。然而定义了AbstractSet的子类AbstractEnumerableSet，这个类增加了抽象的size()和foreach()方法，而且定义了一些有用的非抽象方法toString()等，AbstractEnumerableSet并没有定义add()和remove()方法，它代表只读集合。SingletonSet可以实现为非抽象类。最后定义了AbstractEnumerableSet的子类AbstractWritableSet，这个final抽象集合定义了抽象方法add()和remove()，并实现了union()等具体方法。AbstractWritableSet是Set和FilteredSet类相应的父类。但这个例子中并没有实现它，而是实现了一个新的ArraySet的非抽象类。
子类的部分已经敲完了，如果其中有任何错误，请给我留言，不胜感激！
