ClassA.staticMethod = function () {
}

ClassA.prototype.instanceMethod = function () {
}

在我这个实现当中，一个类的继承是拷贝父类的所有类方法，这样子类就有了父类的静态方法。
然后让子类的prototype.prototype指向父类的prototype.
然后可以根据自己的需要，重写一些方法。
function ClassB() {
}
ClassB.staticMethod = ClassA.staticMethod;
ClassB.prototype.prototype = ClassA.prototype;
ClassB.prototype.instanceMethod = function () {
// method 2
}

对于子类，使用一个prototype的链，来实现方法的实例方法的继承。之所以选择这种实现方法，是因为子类是要重写其中的某些方法的。而
prototype又是一个reference，所以直接的写作ClassB.prototype =
ClassA.prototype，会在重写ClassB的实例方法的同时，破坏ClassA的实例方法。而修改后的方法则会屏蔽父类的。

寻找方法的顺序是，instanceA.prototype.method -> ClassA.prototype.
此时对于类方法的继承，已经实现，现在需要实现在子类中，调用父类的方法。
对于Java，这样的使用是很平常的
public void method() {
super.method();
}
在JavsScript中，为了实现此类功能，所以必须保留一个parent的reference，指向ParentClass.prototype.
ClassB.prototype.parent = ClassA.prototype.
那么在instanceB里面调用this.parent.method.call(this);就可以使用父类的方法了。使用call调用，是为了把自己的数据传到父类。更漂亮的解决方法，我还没有想到。

所以完成的代码是
function ClassA() {
}

ClassA.prototype.method1 = function () {
}

ClassA.staticMethod = function () {
}

function ClassB(){
}

ClassB.staticMethod = ClassA.staticMethod;

ClassB.prototype.prototype = ClassB.prototype.parent = ClassA.prototype;

这个我抽象出来一个extend方法，

var LCore = function () {
}

LCore.extend = function (destination, source) {
// copy all functons
for (var prop in source) {
if (prop == “prototype”) {
continue;
}

destination.prototype[prop] = source[prop];
}

// make a reference for parent and reference prototype
destination.prototype.prototype = destination.prototype.parent = source.prototype;

return destination;
}

问题的提出：
在一个系统中，需要提供一系列的服务（假设这个服务是购买键盘，买电，租用电脑等假象的情况），这些服务以购买产品的形式出现。比如一个产品可以包含一些
服务（同时买2个键盘）。这里，有很多的备选资源，比如有无限多的键盘，还有唯一的比如IBM电脑一台，DELL电脑一台。这些资源都是购买，租用服务的
备选资源。
此时对于键盘等消耗品，使用坏了，就得买新的，对于唯一的IBM电脑，可以租用一定的时间。
问题就是，如何设计这个系统。

也许到这里，你看的还不是特明白，那么我直接说两个有分歧的设计方法吧。
对于所有的无限的资源（比如电能），这个很好说，加入张三买电100度，给你，并且产生一个用电的服务。这个服务一直处于等待状态，张三来了，就可以用这100度电，并且不断的减少。
对于电脑的租用，虽然都是租用，但是由于电脑不同（一个IBM的，一个DELL的），所以产生两个不同的租用服务，都是等待状态，用于处理不同的电脑。
这是一个基于服务的模型，一个系统有很多的（可能是无限多的）服务，每个服务都在等待，等使用的资源没有了，那么销毁这个服务。

这个是我反对的设计模型，因为我认为在某些服务（比如租用电脑），这个不管资源是什么，他都是一个相同的动作，完全是可以抽象出来的。而对于电脑，作为可申请的资源，对外销售。用户买的是资源，而不是买直接的服务。最后做事情是有对应的服务＋资源实现的。
一个服务是否可以运行，首先检查是否有可用的资源，然后检查一些其他的服务限制条件（比如暂时停止本服务等）。这个状态是在申请的时刻，根据服务的这个动
作和相关的数据（比如租用什么电脑，是否到租用期）计算出来的。为了提高效率，应该是在这个时候，应该单独的启用一个线程来处理这个请求。就好像
apache处理一个请求。
处理就是动作（复制到新线程的）＋数据，判断状态，得到结果。

1. 对于资源的申请，可以仿照一些现有的系统。比如内存的申请。
2. 对于服务的工作，可以仿照apache的系统。

可见，我的这个设计，主要是考虑到不同的类的职责的划分。还有就是尽量的遵循现有的系统的设计思想。虽然是在很多不同的领域，但是他的设计思想还是
很可以复用的。那么这个已经很成熟的设计，肯定会把可能遇到的问题，解决方案都有完备的记录。那么这样就能够节省很多时间。没必要重复的发明轮子。

我们还有一个有分歧的地方，就是，他们认为所有的server单独处理，是可以记录状态并且在出问题的时候，容易定位。
我的想法是，假设系统运转无误，在做所有动作的时候记录日志，并且记录数据。这个时候整个的系统，在没有日志组件的时候，也是可以运转的。并且这个对日志的记录也是参照现在操作系统，数据库系统设计的。
还是那句话，参照现有的成熟的设计思想。

不知道大家有什么想法和见解，请大家不吝赐教。