Javascript高级程序设计——面向对象之实现继承

原型链：

　　构造函数中都有一个prototype属性指针，这个指针指向原型对象，而创建的实例也有指向这个原型对象的指针__proto__。当实例查找方法时先在实例上找，找不到再通过__proto__到原型对象上查找。如果原型对象是另一个类型的实例，那么原型对象包含一个指向另一个原型对象的指针、另一个原型对象中也包含指向另一个构造函数的指针。

原型连继承
function superValue(){

    this.superValue = "superValue";

}

superValue.prototype.getSuperValue(){

    return this.superValue;

}

function subValue(){

    this.subValue = "subValue"；

}

subValue.prototype = new superValue();

//原型被superValue实例替换，实现继承superValue的属性和方法。没有了constructor

subValue.prototype.getSubValue = function(){

    return this.subValue;

}

var instance = new subValue();

instance instanceof Object

//true，所以的引用类型都继承Object，也是通过原型链继承的。

instance instanceof superValue;    //true

instance instanceof subValue;      //true

//只要原型链出现过的构造函数，结果就返回true。

所以的函数类型都是Object的实例，所以instance instanceof Object 返回true

问题：

通过原型继承时会共享所有引用类型的属性

不能向超类的构造函数传递参数。

借用构造函数：

又名伪造对象。在子类型的函数的内部调用超类的构造函数

function superValue(){

    this.colors = ["yellow", "green", "red"];

}

function subValue(){

    //继承了superValue

    superValue.call(this);

}

var instance1 = new subValue();

instance1.color.push("new");

instance1.color         //["yellow", "green", "red", "new"]

var instance1 = new subValue();

instance1.color         //["yellow", "green", "red"] 不共享属性

问题：构造函数的内部调用父类的构造函数，无法实现函数复用

组合继承：

利用原型链实现方法的继承，达到函数复用。

利用构造函数实现实例的属性继承，避免了引用实例的共享问题

function superValue(name){

    this.name = name;

    this.color = ["red", "green"];

}

superValue.prototype.sayName = function(){

    alert(this.name);

}

function subValue(age, name){

    superValue.call(this, name);      //对构造函数的属性的继承

    this.age = age;

}

//实现继承superValue

subValue.prototype = new superValue();

//恢复被覆盖的构造函数

subValue.prototype.constructor = subValue;

//定义自己的方法

subValue.prototype.sayAge = function(){

    alert(this.age);

}

var instance = new subValue(24, "yang");

instance.color.push("black");

instance.color                       //["red", "green", "black"];

instance.sayName()                   //yang 继承来的方法

instance.sayAge()                    //24 自己的方法

var instance2 = new subValue(25, "he");

instance.color                        //["red", "green"]不共享引用类型。

instance.sayName()                   //he 继承来的方法

instance.sayAge()                    //25 自己的方法

问题：继承时调用了两次supeValue（）一次函数内部，一次实例化原型对象，子类型屏蔽了原型对象上的属性，可以通过寄生组合类型继承解决。

　　原型继承：

function object(obj){

    funciton F();            //声明一个临时的构造函数

    F.prototype = obj;        //实现原型继承

    return new F();            //返回构造函数实例。

}

//整个过程是一个浅复制

　　寄生式继承：

　　与寄生构造函数和工厂模式类似，即创建一个仅用于封装过程的函数，在内部增强对象。
function object(obj){

    var clone = object(obj);

    clone.sayName = function(){

        alert(haha"");

    }

    return clone;

}

//函数内部增强对象

　　寄生组合类型继承:

　　解决组合继承中两次调用superValue（）函数。这两次调用superValue（）会在原型对象和新对象上创建属性。

function superValue(name){

    this.name = name;

    this.color = ["red", "green"];

}

superValue.prototype.sayName = function(){

    alert(this.name);

}

function subValue(age, name){

    superValue.call(this, name);      //调用父类构造函数创建属性name和color。屏蔽原型上的属性name和color

    this.age = age;

}

//实现继承superValue,在原型上创建属性name和color

subValue.prototype = new superValue(); 

subValue.prototype.constructor = subValue;

subValue.prototype.sayAge = function(){

    alert(this.age);

}

解决：通过寄生组合式继承，通过借用构造函数来继承属性，通过原型链混成形式继承方法

方法：不必为了指定子类型的原型而调用超类的构造函数。通过寄生式继承超类原型，指定给子类原型

function inheritPrototype(subType, superType){

    var prototype = object(super.prototype);　　　　//创建对象

    prototype.constructor = subType;　　　　　　　　　//增强对象

    subType.prototype = prototype;  　　　　　　　　  //指定对象

}

寄生组合继承代码

function superValue(name){

    this.name = name;

    this.color = ["red", "green"];

}

superValue.prototype.sayName = function(){

    alert(this.name);

}

function subValue(age, name){

    superValue.call(this, name);    //实现属性的继承

    this.age = age;

}

//原型链方法继承

inheritPrototype(subType, superType);

subValue.prototype.sayAge = function(){

    alert(this.age);

}

巴特西

Javascript高级程序设计——面向对象之实现继承

最新文章

热门文章