Implementation _javascript techniques for a JavaScript inheritance

Author: Yin Wei-ming

blog:http://my.donews.com/yinwm/

As my previous article says, for JavaScript, a class is a function, and his class method (that is, static) is part of the function, and the instance method is above the prototype.
function ClassA () {
}

Classa.staticmethod = function () {
}

ClassA.prototype.instanceMethod = function () {
}

In my implementation, the inheritance of a class is a copy of all the class methods of the parent class, and the class has a static method of the parent class.
Then let the prototype.prototype of the subclass point to the prototype of the parent class.
You can then rewrite some of the methods according to your needs.
function ClassB () {
}
Classb.staticmethod = Classa.staticmethod;
ClassB.prototype.prototype = Classa.prototype;
ClassB.prototype.instanceMethod = function () {
Method 2
}

For subclasses, a prototype chain is used to implement the inheritance of instance methods of the method. This implementation is chosen because subclasses are overriding some of these methods. And prototype is a reference, so the direct writing classb.prototype = Classa.prototype, will be in the rewrite ClassB instance method, destroys the ClassA instance method. The modified method masks the parent class.

The order of search methods is, InstanceA.prototype.method-> classa.prototype.
In this case, the inheritance of the class method has already been implemented, and you now need to implement the method that invokes the parent class in the subclass.
For Java, this is a common use.
public void Method () {
Super.method ();
}
In Javsscript, in order to implement such functions, one parent's reference must be retained, pointing to Parentclass.prototype.
ClassB.prototype.parent = Classa.prototype.
Then call This.parent.method.call (this) in the INSTANCEB, and you can use the method of the parent class. Called using call to upload your data to the parent class. More beautiful solution, which I had not thought of.

So the complete code is
function ClassA () {
}

ClassA.prototype.method1 = function () {
}

Classa.staticmethod = function () {
}

function ClassB () {
}

Classb.staticmethod = Classa.staticmethod;

ClassB.prototype.prototype = ClassB.prototype.parent = Classa.prototype;

This I abstracted out a extend method,

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;
}