javascript学习——继承

  原型链：利用原型让一个引用类型继承另一个引用类型的属性和方法。具体的操作是将子引用类型的原型变为父引用类型原型的一个实例。

function SuperType(){
    this.age = 20;
}
SuperType.prototype.getSuperAge = function(){
   return this.age;
}

function SubType(){
   this.name = "xiaoming";
}

SubType.prototype = new SuperType();
SubType.prototype.getSubName = function(){
  return this.name;
}

var instance = new SubType();
alert(instance.getSuperAge()); //20

  这里将subType的原型替换为superType(),也就是说，subType.prototype的[[prototype]]指向了superType.prototype。因此，subType可以顺着原型链一直向上，拥有subType,superType的所有属性和方法。需要注意的是，此时subType的construcor变成了superType的。

  所有的函数都默认集成Object，因此每一个函数都有toString(),valueOf()方法。

  如果想要确定原型和实例之间的关系，可以用关键字instanceof 或者方法isPrototypeOf(）方法。

  注意：要谨慎的定义方法，需要先继承父类，然后再重写超类型中的方法或者添加新方法。同时需要注意的是，在实现原型链继承的时候，不能通过对象字面量创建原型方法，原理类似于创建对象的原型模型。这样会切断原型和实例之间的联系。

借用构造函数：为了解决集成父类引用类型的问题，可以将父类的继承放在子类的构造函数里面。这样每次都得到一个新的父类的实例，可以得到不同的引用变量的副本。同时可以实现构造函数参数的传递。

function SuperType(name){
  this.name = name;
  this.colors = ["red","blue","yellow"];
}
function  SubType(age){
   SuperType.call(this,"xiaoming");
   this.age = age;
}

var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors);//red blue,yellow,black

var instance2 = new SubType();
instance2.colors.push("white");
alert(instance2.colors);//red,blud,yellow,white

组合继承：借用构造函数继承实例的属性，借用原型链实现原型属性和方法的继承。

function SuperType(name){
    this.name = name;
    this.colors = ["red","blue","yellow"];
}

SuperType.prototype.sayName = function(){
   alert(this.name);
};

function SubType(name,age){
    SuperType.call(this,name);

     this.age = age;
}

//实现继承
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
   alert(this.age);
}

var instance1 = new SubType("xiaoming",20);
instance1.colors.push("black");
alert(instance1.colors);//red,blue,yellow,black
instance1.sayName();//xiaoming
instance1.sayAge();//20

var instance2 = new SubType("xiaohong",29);
instance2.colors.push("white");
alert(instance2.colors);//red,blue,yellow,white
instance2.sayName();//xiaohong

原型式继承：在函数内部创造一个临时的构造函数，将传入的对象作为该构造函数的原型，再返回该临时类型的新实例。该方法的思想是实现了传入对象的一个浅复制，但是引用变量还是公用的。ECMAScript5定义了一个Object.create()方法，规范了原型式继承。

var Person = {
   name: "xiaohong",
   colors:["red"];
}

var person1 =Object.create(Person);
person1.name = "xiaogang";
person1.colors.push("blue");

var person2 = Object.create(Person);
person2.name = "xiaoming";
person2.colors.push("yellow");

alert(person.colors);//red,blue,yellow

寄生组合式继承：最推荐的方式，该方借用构造函数来继承属性，借用原型链继承原型的方法和属性。不必为了子类型的原型而指定超类型的构造函数，只要一个超类型的副本即可。这样可以避免两次调用超类型的构造函数。

function inherentPrototype(subType,superType){
    var prototype = Object(superType.protoType);
    prototype.constructor = subType;
    subType.prototype = prototype;
}

function SuperType(name){
   this.name = name;
}
SuperType.prototype.SayName = function(){
  alert(this.name);
};
function SubType(name,age){
   SuperType.call(this,name);

   this.age = age;
}

inherentPrototype(SubType,SuperType);
SubType.prototype.SayAge = function(){
   alert(this.age);
};

  只调用了一次SuperType的构造函数，避免了在SubType.prototype上创建不必要的属性，同时原型链保持不变。