继承

//父类构造函数
function Person(name){
    this.name = name;
    this.sum = function(){
        alert(this.name)
    }
}

//原型上的属性和方法
Person.prototype.age = 10;
 

一、原型链继承( 函数原型指向另一个函数的实例 )

  • 既可以继承构造函数的属性和方法,
  • 又可以继承原型链上的属性和方法
  • 实例化子类不能给父类传参
//原型链继承
function Per(){
   
}
Per.prototype = new Person();//可以传参,不实用
var per1 = new Per()//不能传参给 Person
 

二、构造函数继承( 对象冒充实现继承 )

  • 只能继承构造函数上的属性和方法(不能继承原型上)
  • 实例化子类能给父类传参
//借用构造函数继承
function Con(){
    //只可以拿到Person里面的属性和方法
    //没有new Person()实例,所以不能继承原型上的方法
    Person.call(this,"jer");
    this.age = 12;
}
var con1 = new Con();
console.log(con1.name);//jer
console.log(con1.age);//12
console.log(con1 instanceof Person);//false
 

三、组合继承(组合原型链继承和借用构造函数继承)(常用)

  • 既可以继承构造函数的属性和方法,又可以继承原型链上的属性和方法。
  • 实例化子类能给父类传参
  • 父类构造函数调用两次,消耗内存

//组合原型链和构造函数继承

function SubType(name){
    Person.call(this,name);//借用构造函数模式}

//SubType.prototype = Person.prototype ;//原型链继承
SubType.prototype = new Person();//原型链继承

var sub = new SubType("gar");  //传递参数
console.log(sub.name);//gar 继承了构造函数属性
console.log(sub.age);//10 继承了父类原型的属性
 

四、原型式继承

  • 所有实例都会继承原型上的属性
  • 无法实现复用。(新实例属性都是后面添加的)
//先封装一个函数容器,用来输出对象和承载继承的原型
function content(obj){
    function F(){};
    F.prototype = obj;//继承了传入的参数
    return new F();
}
var sup = new Person();//拿到父类的实例
var sup1 = content(sup);
console.log(sup1.age);// 10 继承了父类函数的属性
 

五、寄生式继承

  • 式继承在原型外面套了个壳子
  • 无法复用
function content(obj){
    function F(){};
    F.prototype = obj;//继承了传入的参数
    return new F();//返回函数对象
}
var sup = new Person();
//以上是原型是继承,给原型是继承再套一个壳子传递参数
function subobject(obj){
    var sub = content(obj);
    sub.name = "gar";
    return sub;
}
var sup2 = subobject(sup);
//这个函数经过声明之后就成了可增添属性的对象
console.log(typeof subobject);//function 
console.log(typeof sup2);//object
console.log(sup2.name);//gar,返回了一个sub对象,继承了sub的属性
 

六、寄生组合式继承(常用)

//寄生
function content(obj){
    function F(){};
    F.prototype = obj;
    return new F();
}
//con实例(F实例)的原型 继承了父类函数的原型
var con = content(Person.prototype);

//继承了父类构造函数中的属性和方法
function Sub(){
    Person.call(this);
}

//继承了con实例
Sub.prototype = con;

//再将con的构造函数指向Sub
con.constructor = Sub;

//sub的实例就继承了构造函数属性,父类实例con的函数属性
var sub1 = new Sub();
console.log(sub1.age);//10;
 

//上述和以下例子的效果是一样的
function F(){};
F.prototype = Person.prototype;
function Sub(){
    Person.call(this);
}
Sub.prototype = new F();
var sub2 = new Sub();
console.log(sub2.age);
 

    
  

原创文章,作者:我心飞翔,如若转载,请注明出处:https://www.pipipi.net/14800.html

发表评论

登录后才能评论