javascript之继承

一、类与对象

 1、对象与类

 var a={};//对象，无法用new实例化
     function Person(name){
      this.name=name;
}
Person.prototype.showName=function(){
  alert(this.name);
}
  var p=new Person("zhangmeng");
   p.showName();

组合使用构造函数模式和原型模式实现的类：

构造函数定义属性；原型实现定义方法和属性共享

function Person(name,age,job){
 this.name=name;
 this.age=age;
 this.job=job;
this.friends=["y"]//共享属性
}//构造函数定义实例属性
Person.prototype={
constructor:Person,
sayName:function(){
      alert(this.name);
 }//原型模型用于定义方法和共享属性
}
 var p1=new Person("zhangmeng",24,"Coding");
 var p2=new Person("jiangyu",26,"Fighting");
p1.friends.push("dy");
console.log(p1.friends);
console.log(p2.friends);
 p1.sayName();
 p2.sayName();

 

2、constructor和prototype

constructor是对象的属性（Object）

prototype是函数的属性（Object），构造函数的prototype指向原型对象，它含有constructor指向构造函数。

 

3、instanceof和constructor判断对象类型

var d=new Date();

d.constructor==Date;//true

d instanceof Date //true

区别：d instanceof Object；//true

d.constructor==Object;//false

contructor不识别继承的类型

 

二、继承

1、理解构造函数、原型对象、实例的关系

构造函数中含有原型对象，原型对象包含指向构造函数的指针（constructor）；实例中包含内部属性_proto_指向原型对象。

 

2、原型链继承

   function SuperType(){
            this.property = true;
        }
        SuperType.prototype.getSuperValue = function(){
            return this.property;
        };//父类
        function SubType(){
            this.subproperty = false;
        }//子类
        //inherit from SuperType
        SubType.prototype = new SuperType();

        SubType.prototype.getSubValue = function (){
            return this.subproperty;
        };
        var instance = new SubType();
        alert(instance.getSuperValue()); //true

        alert(instance instanceof Object); //true
        alert(instance instanceof SuperType); //true
        alert(instance instanceof SubType); //true

        alert(Object.prototype.isPrototypeOf(instance)); //true
        alert(SuperType.prototype.isPrototypeOf(instance)); //true
        alert(SubType.prototype.isPrototypeOf(instance)); //true

     子类通过修改prototype属性，继承父类，实现原型链，而实现继承。当子类实例调用父类方法时候，搜索的步骤是：

1）实例化对象。2）子类方法。3）父类方法。4）Object，所有对象的祖先。

    缺点：包含引用类型的原型，包含引用类型的原型属性会被所有实例共享；不能向超类构造函数传递参数。

 

3、call和apply方法

 call和apply都是Function对象的方法，可用来改变对象的内部指针。JS说明如下：

call 方法
调用一个对象的一个方法，以另一个对象替换当前对象。
call([thisObj[,arg1[, arg2[,   [,.argN]]]]])
参数：thisObj可选项。将被用作当前对象的对象。arg1, arg2,  , argN可选项。将被传递方法参数序列。
说明：call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。
如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。

apply传入第二个参数是数组形式，如 func.call(func1,var1,var2,var3)对应的apply写法为：func.apply(func1,[var1,var2,var3])

例 var func=new function(){this.a="func"}
    var myfunc=function(x){
        var a="myfunc";
        alert(this.a);
        alert(x);
    }
    myfunc.call(func,"var");// 弹出func和var

 

4、借用构造函数（Constructor Stealing）实现继承

 

function SuperType(name){
   this.name=name;
   this.colors=["blue","green"];
}
function SubType(){
   SuperType.call(this,"zhangmeng");//利用call在SubType的环境下调用SuperType的方法
}
var instance1=new SubType();
instance1.colors.push("black");
var instance2=new SubType("jiangyu");
console.log(instance1.colors);//blue green black
console.log(instance2.colors);//blue green
console.log(instance1.name);zhangmeng
console.log(instance2.name);jiangyu

缺点：无法实现复用。

 

5、组合继承(Conbination inheritance)***

 构造函数实现对实例属性的继承；原型链实现方法和原型（共享）属性的继承：

function SuperType(name){
 this.name=name;
 this.friends=["y"];
}
SuperType.prototype={
constructor:SuperType,
sayName:function(){
   alert(this.name);
}
}
 
function SubType(name,age){
  SuperType.call(this,name);//构造函数实现对实例属性的继承
  this.age=age;
}
SubType.prototype=new SuperType();//原型链实现对原型属性和方法的继承
 
SubType.prototype.sayAge=function(){
alert(this.age);
}
var sub1=new SubType("zhangmeng",24);
sub1.sayName();
sub1.sayAge();
sub1.friends.push("dy");
console.log(sub1.friends);
 
var sub2=new SubType("jiangyu",26);
sub2.sayName();
sub2.sayAge();
sub2.friends.push("xp");
console.log(sub2.friends);
 

缺点：两次调用超类构造函数

 

6 寄生组合式继承（YUI：YAHOO.long.extend）

 

由于重写类型：SuperType.call(this,name),失去默认的constructor因此重新创建即可代替

SubType.prototype=new SuperType(),

减少一次调用,实现代码:

 
function inheritPrototype(subType,superType){
     var prototype=object(superType.prototype);//创建超类原型对象副本
     prototype.constructor=subType;//弥补由于call方法失去的默认constructor属性
     subType.prototype=prototype;//子类的prototype指向超类的原型对象
}
 
function SuperType(name){
 this.name=name;
 this.friends=["y"];
}
SuperType.prototype={
constructor:SuperType,
sayName:function(){
   alert(this.name);
}
}
 
function SubType(name,age){
  SuperType.call(this,name);//构造函数实现对实例属性的继承
  this.age=age;
}
//改写为：
inheritPrototype(SubType,SuperType);
SubType.prototype.sayAge=function(){
alert(this.age);
}
var sub1=new SubType("zhangmeng",24);
sub1.sayName();
sub1.sayAge();
sub1.friends.push("dy");
console.log(sub1.friends);
 
var sub2=new SubType("jiangyu",26);
sub2.sayName();
sub2.sayAge();
sub2.friends.push("xp");
console.log(sub2.friends);