继承 - 简书

（文章仅用于梳理继承知识点，想深入了解需要看书）
我们知道，面向对象的三大特性：封装、继承、多态。讲到继承，在现实中，有子承父业的说法，大概意思是儿子拥有了父亲的一切。在javascript中，如果对象a能访问到对象b的所有属性和方法，我们就可以说a继承b。
相比于java的类继承，javascript中一般使用原型链来实现继承。回顾下原型、实例、构造函数的三者关系。当实例对象访问一个变量时，如果在当前实例中找不到相应的标志符，则会在原型对象中查找。想象一下，如果原型对象是另一个类型的实例呢？那么在当前原型对象搜索不到结果时，会到另一个类型的原型对象上查找，如此下来，便形成了一个链状结构。因而，就本质而言，javascript通过重写原型来实现继承。

function Super(){
    this.type='super'
}
Super.prototype.getType = function(){
    return this.type
}
function Sub(){
    this.type = 'sub'
}
Sub.prototype = new Super()
Sub.prototype.name = 'sub'
var a = new Sub()
a.type//sub
a.getType()//sub

常言说，青出于蓝而胜于蓝。在javascript中的体现则是重写原型方法。

function Super(){
    this.type='super'
}
Super.prototype.getType = function(){
    return this.type
}
function Sub(){
}
Sub.prototype = new Super()
Sub.prototype.getType = function(){
  return 'new type:'+this.type
}
var a = new Sub()
a.getType()//new type:super

单纯的原型方法来实现继承时，会有一个问题。由于用了原型，所以原型方法会被所有实例共享的问题也会暴露。由于由于重写原型链的缘故，父类型的实例属性变成字类型实例对象的原型属性。

于是，我们可以借用构造函数来避免这一点。


function Super(){
    this.child=['a','b','c']
}
Super.prototype.getChild = function(){
    return this.child
}
function Sub(){
    Super.apply(this,arguments)
}
var a = new Sub()
var b = new Sub()
a.child.push('d')
b.child//['a','b','c']

然而单纯的构造函数则无法继承父类型的原型方法和属性。因而在实例情景中，我们往往两者结合。构造函数负责处理父类型实例属性和方法，原型则处理父类型原型属性和方法。为了避免两次调用父类型构造函数（第一次在子类型原型赋值给父类型的实例化对象，第二次是实例子类型时，借用了父类型构造函数），我们会引入一个中间函数来做过渡。(寄生组合继承)

function Sup(){
    this.type='sup'
}
Sup.prototype.getType = function(){
    return this.type
}
function f(){}
f.prototype = Sup.prototype
function Sub(){
    Sup.apply(this,arguments)
    this.type = 'sub'
}
Sub.prototype = new f()
var a= new Sub()
a.getType()

由于这些继承方式写法繁琐，所以es6制定了一个语法糖。我们可以像写java继承的方式来写javascript继承

class Sup{
    constructor(){
        this.type='sup'
    }
    getType(){
        return this.type
    }
}

class Sub extends Sup{
    constructor(){
        super()
        this.name = 'a'
    }
    getType(){
        return 'a'
    }
}
var a = new Sub()

注意点：如果要重写子类型的构造函数，需要先调用super方法。

继承

推荐阅读更多精彩内容