javascript中的继承用法

本文实例汇总了javascript关于继承的用法,但愿本文所述对你们的javascript程序设计有所帮助。分享给你们供你们参考。具体以下：
代码以下:

/**
* 实现子类继承父类,但不会产生多余的属性和方法
* @returns {Function}
*/
define(function(){
return function(subType, superType){
var proto = new Object(superType.prototype);
proto.constructor = subType;
subType.prototype = proto;
};
});
//——————————————————————————
define(function(){
function ostring(s)
{
this.str = s;
this.length = this.str.length;
}
ostring.prototype.show = function(){
alert(this.str);
};
return ostring;
});
//——————————————————————————
define(['inherit', 'ostring'], function(inherit, ostring){
function wstring(s){
//用call实现调用父类构造函数
ostring.call(this, s);
this.chlength = 2 * s.length;
}
//继承其余的属性
inherit(wstring, ostring);
wstring.prototype.add = function(w)
{
alert(this.str + w);
};
return wstring;
});

1、用function实现：

function Person(name) {
    this.name = name;
}
Person.prototype.getName = function() {
    return this.name;
}
function Author(name, books) {
    this.inherit=person;
    this.inherit(name);
    this.books = books;
    
}
var au=new Author("dororo","Learn much");
au.name

或者同等效力的：

function Person(name) {
    this.name = name;
}
Person.prototype.getName = function() {
    return this.name;
}
function Author(name, books) {
    Person.call(this, name);
    this.books = books;
    
}
var au=new Author("dororo","Learn much");
au.getName

因为这只是将this做为参数，调用父类Person的构造函数，把赋予父类的全部域赋予Author子类，因此任何父类Person构造函数以外的定义的域（原型prototype），子类都不会继承。因此上面例子中，au.getName将是没有被定义的（undefined），由于getName是在Person的原型对象中定义的。

并且，子类的构造函数要在定义本身的域以前调用父类构造函数，省得子类的定义被父类覆盖掉。也就是说，Author定义属性book要在Person.call以后，不然会被Person中属性覆盖。同时，在子类中也最好不要用prototype来定义子类的函数域，由于在一个子类被new，实例化以后就要执行prototype，而后才是调用父类的构造函数，这样也容易被父类的属性覆盖掉。

2、用prototype实现：

function Person(name) {
    this.name = name;
}
Person.prototype.getName = function() {
    return this.name;
}
function Author(name, books) {
    this.books = books;  
}
Author.prototype=new Person(name);
Author.prototype.constructor=Author;
Author.prototype.getBooks = function() {
    return this.books;
}
var au1=new Author("dororo1","Learn much");
var au2=new Author("dororo2","Learn less");
alert(au1.getName());
alert(au2.getName());

这种方法避免了function实现中，没法继承prototype的问题。由于 Author.prototype=new Person(name);new Person（）实例会调用Person构造和原型的全部属性。可是缺点是已经实例化了Author.prototype。因此当子类实例化的时候，全部非基本数据类型都是reference copy。因此上面例子中，不管实例au1,仍是au2返回的值都是dororo1.

3、用“混合”实现

function Person(name) {
    this.name = name;
}
Person.prototype.getName = function() {
    return this.name;
}
function Author(name, books) {
    this.base = new Person(name);
    for(var key in this.base){
        if(!this[key]){
           this[key]=this.base[key];
           }
           }
    this.book=books;
}
var au1=new Author("dororo1","work");
var au2=new Author("dororo2","play");
alert(au1.getName());
alert(au2.getName());
au1.book;
au2.book;
 

属于扩展，把父类的全部域都拷贝到子类。彻底没有上述两方面的问题。
寄生组合模式）

JS的继承包括属性的继承和方法的继承，他们分别经过不一样的方法来实现。
1.属性的继承

属性的继承经过改变函数的执行环境来实现的。而改变函数的执行环境可使用call()和apply()两种方法来实现。

咱们首先建立一个Animal“类”（由于JS中没有类的概念，这里只是一个模拟，它实际上只是一个Function函数对象）。

function Animal(typeName) {
//为当前方法的执行环境(this)添加一个属性typeName
//可是执行环境(this)要执行这个函数的时候才能肯定
this.typeName = typeName;
this.colors = ["red","while"];
}
//想函数的原型里 添加 两个（对象共享的）的方法
Animal.prototype.Shout = function () { alert("我是：--" + this.typeName);};
Animal.prototype.Eat = function () { alert("我是：--" + this.typeName) };
//--定义一个狮子--“类”（其实就是一个函数）
function Lion(tn) {
//--执行Animal方法，并经过apply的第一个参数 修改了Animal的执行环境为Lion的this
//一样的，Lion的this，也要在执行的时候才能肯定是谁
Animal.apply(this,["狮子"]);//--继承了父类的变量属性，this由于是new了Lion，this是Lion
}
Lion.prototype = Animal.prototype; //继承父类的方法，搞定--可是这写很差，当子类再添加方法时候，父类一样也有此方法，这是指针引用
Lion.prototype.Hunt = function () {
alert("我是：狮子，我要去捕猎~~·~");
}
var aminm = new Animal();
aminm.Hunt(); //---能够访问到子类的方法，这样就很差了
//----那么如何解决这个问题呢》？？？？？？
//---解决方案：继承方法时候能够这样写：
Lion.prototype = new Animal();//继承父类的方法，把Animal对象赋给了prototype原型，其实它里面也有属性
var lion = new Lion(); //new 关键字除了建立的，还会修改Lion对象的执行环境为Lion对象自己
// ---换句话说，就是new完了以后，Lion函数里的this就是Lion函数自己了，而后调用Lion函数

new关键字做用解析：

而new关键字是十分伟大的，在上段代码中，new关键字完成了如下几项工做:

1. 开辟堆空间，以准备存储Lion对象
2. 修改Lion对象自己的执行环境，使得Lion函数的this指向了Lion函数对象自己。
3. 调用Lion“类”的“构造函数”，建立Lion对象
4. 将Lion函数对象的堆地址赋值给变量l，这个时候l就指向了这个Lion函数对象

   lion.Shout();
   lion.Eat();

   可是这种继承有个缺点：就是父类的构造函数的被调用了两次，call一次，而后new又一次。