Javascript 面向对象的类与继承

原型链继承

function User(){
    this.name = 'zs'
    this.colors=['red','black']
}
User.prototype.getName = () => this.name

function Admin(){}
// Admin 继承 User
// 本质：重写原型对象，将一个父对象的属性和方法作为一个子对象的原型对象和方法
// Admin.prototype = new User()
Admin.prototype = Object.create(User.prototype)  // 推荐写法

// 优点：简单   
// 缺点：1、属性被实例共享 2、不能向父级传递参数

构造函数继承

function User(name){
    this.name = name
    this.colors=['red','black']
}
User.prototype.getName=function(){
    return this.name
}

function Admin(name){    
    // 继承了User
    // 让父类的实例属性继承下来，实例修改引用类型的值，另一个实例的引用类型的值不会发生变化
    User.call(this,name)
}

// 缺点：1、方法在构造函数中定义，创建实例都会创建一遍方法   2、父类定义的共享方法不能被子类继承

组合继承

function User(name){
    this.name = name
    this.colors=['red','black']
}
User.prototype.getName=()=>this.name

function Admin(name){ User.call(this,name) }

// 重写原型对象：吧父类的共享方法继承下来
Admin.prototype = Object.create(User.prototype);
Admin.prototype.constructor = Admin;

// 优点：有前两种的优点，最常用		
// 缺点：1、调用两次父级构造函数

原型式继承

function CreateObj(o){
	function F(){}
  F.prototype = o
  return new F()
}
// 优点：简单     
// 缺点：属性被实例共享

寄生式继承

function createObj(o){
    const clone = Object.create(o)
    clone.sayName = function(){}
    return clone
}
// 缺点，优点：方法在构造函数中定义，创建实例都会创建一遍方法

寄生组合式继承

function User(name){
    this.name = name
    this.colors=['red','black']
}
User.prototype.getName = () => this.name

function Admin(name){ User.call(this,name) }

Admin.prototype = Object.create(User,prototype)
Admin.prototype.constructor = Admin

// 优点：1、高效率，只调用一次父构造函数 2、原型链不变

class

class A{
	constructor(name){
        this.name = name
    }
    sayName(){
        console.log(this.name)
    }
}

class B extends A{
    constructor(name){
		super(name)
    }
}
const BB = new B('zk')	
console.log(BB.name) //zk
BB.sayName() //zk

总结

• 原型链继承

  • 优点：重写子类的原型对象，父类原型对象上的属性和方法都会被子类继承
  • 缺点：再父类中定义的实例引用类型的属性，一旦被修改，其它的实例也会被修改，当实例化子类的时候，不能传递参数给父类

• 借用构造函数模式

  • 原理：改变父类中的 this 指向
    

  • 特点：在子类构造函数内部直接调用（ call()，apply()，bind() ） 父类的构造函数
    

  • 优点：仅仅的是把父类中的实例属性当作子类的实例属性，并且可以传参
    

  • 缺点：父类中共有方法不能被继承
    

• 组合继承

  • 优点：结合了原型链继承和借用构造函数继承的优点
    

    • 原型链继承：公有方法能被继承下来
    • 借用构造函数：实例属性能被子类继承下来

  • 缺点：调用两次父类的构造函数
    

    • 1、实例化子类对象
    • 2、子类的构造函数

• 寄生组合式继承

  const b = Object.create(a)

  将 a 对象作为 b 实例的原型对象

  把子类的原型对象指向了 父类的原型对象

  Admin.prototype = Object.create(User,prototype)