继承的核心：
1、__proto__
a、对象特有
b、指向上层（创建自己的那个构造函数）的原型对象（prototype)
c、对象从prototype继承属性和方法
2、prototype:
a、函数特有
b、用于存储共享的方法和属性
3、constructor:
a、函数特有，定义在prototype里面
b、通过new创建实例时，该实例便继承了prototype的属性和方法。
原型链继承
原型链是实现继承最原始的模式，即通过prototype属性实现继承。将父类的实例作为子类的原型。
// 父类型
function Person(name, age, age) {
this.name = name
this.age = age
this.age = age
}
Person.prototype.sayHi = function() {
console.log('大家好，我是' + this.name)
}
// 子类型
function Student() {
this.score = 200
}
Student.prototype = new Person()
Student.prototype.constructor = Student
let s1 = new Student()
s1.sayHi() //大家好我是undefine
console.log(s1.name) // undefine
console.log(s1.age) // undefine
console.log(s1.constructor) // Student
特点：
子类的实例也是父类的实例
优点：
简单易于实现，父类的新增的实例与属性子类都能访问
缺点：
可以在子类中增加实例属性，如果要新增加原型属性和方法需要在new 父类构造函数的后面
无法实现多继承
创建子类实例时，不能向父类构造函数中传参数
image
借用构造函数继承
核心：在子类的内部调用父类，通过call / apply改变父类中this的指向
等于是复制父类的实例属性给子类
特点：
创建子类实例时，可以向父类传递参数
可以实现多继承
可以方便的继承父类型的属性，但是无法继承原型中的方法
缺点：
实例并不是父类的实例，只是子类的实例
无法继承原型中的方法
无法实现函数复用，每个子类都有父类实例函数的副本，影响性能
// 构造器
function Animation (name, age) {
this.age = age
this.name = name
}
Animation.prototype.eat = function() {
console.log(this.name)
}
function Cat(name, age, score) {
Animation.call(this, name, age)
this.sex = sex
this.score = score
}
let c1 = new Cat('tom', 18, '男', 100) // 可以传参
c1.eat() //报错 not a function
console.log(c1 instanceof Animation) //false
console.log(c1 instanceof Cat) //true
组合继承
原型链 + 借用构造函数。取其长避其短：共享的用原型链，各自的借用构造函数
特点：既是子类的实例，也是父类的实例
可传参
函数可复用
function Person (name, age, score) {
this.age = age
this.name = name
this.score = score
console.log('Person' + ' ---- ' + JSON.stringify(this)) // Person
}
Person.prototype.sayHi = function() {
console.log('我叫' + ' ---- ' + this.name) // zs
}
function Student(name, age, score, sex) {
Person.call(this, name, age, score)
this.sex = sex
}
Student.prototype = new Person()
Student.prototype.constrctor = Student
let s1 = new Student('zs', 19, 100 , '男')
console.log('s1' + ' ---- ' + JSON.stringify(s1)) // Student
console.log('实例' + ' ------- ' + s1.name)
s1.sayHi()
依次打印：
Person ---- {}
Person ---- {"age":19,"name":"zs","score":100}
s1 ---- {"age":19,"name":"zs","score":100,"sex":"男"}
实例 ------- zs
我叫 ---- zs
原型式继承
function content(obj) {
function F() {}
F.prototype = obj // 继承了传入的参数
return new F() // 返回函数的对象
}
let sup = new Person() // 拿到父类的实例
let sup1 = content(sup)
console.log(sup1.age)
重点：用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了个可以随意增添属性的实例或对象。
object.create()就是这个原理。
特点：类似于复制一个对象，用函数来包装。
缺点：1、所有实例都会继承原型上的属性。
2、无法实现复用。（新实例属性都是后面添加的）
寄生式继承
function content(obj) {
function F() {}
F.prototype = obj // 继承了传入的参数
return new F() // 返回函数的对象
}
let sup = new Person() // 拿到父类的实例
//以上时原型式继承
function subobject(obj) {
let sub = content(obj)
sub.name = 'gar'
return sub
}
let sup2 = subobject(sup)
//经过该函数声明之后就完成了可添加属性的对象
console.log(sup1.name) // 返回了个sub对象，继承了sub属性
重点：就是给原型式继承外面套了个壳子。
优点：没有创建自定义类型，因为只是套了个壳子返回对象（这个），这个函数顺理成章就成了创建的新对象。
缺点：没用到原型，无法复用。
寄生组合式继承（常用）
function content(obj) {
function F() {}
F.prototype = obj // 继承了传入的参数
return new F() // 返回函数的对象
}
let con = contnet(Person.prototype)
// 组合
function Sub() {
Person.call(this) // 继承了父类构造器的属性
// 避免了组合式继承调用两次构造函数的缺点
}
Sub.prototype = con // 继承了con实例
con.constructor = Sub // constructor重新指向 sub
let sub = new Sub() //Sub实例就继承了构造函数属性，父类实例 con的函数属性
Class类
ES6引进了class关键字，用于创建类，这里的类是作为ES5构造函数和原型对象的语法糖存在的，其功能大部分都可以被ES5实现，不过在语言层面上ES6也提供了部分支持。新的写法不过让对象原型看起来更加清晰，更像面向对象的语法而已。
//定义类
class Point {
constructor(x, y) {
this.x = x;
this.y = y;
}
toString() {
return '(' + this.x + ', ' + this.y + ')';
}
}
var point = new Point(10, 10);
我们看到其中的constructor方法就是之前的构造函数，this就是之前的原型对象，toString()就是定义在原型上的方法，只能使用new关键字来新建实例。语法差别在于我们不需要function关键字和逗号分割符。其中，所有的方法都直接定义在原型上，注意所有的方法都不可枚举。类的内部使用严格模式，并且不存在变量提升，其中的this指向类的实例。
new是从构造函数生成实例的命令。ES6 为new命令引入了一个new.target属性，该属性一般用在构造函数之中，返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的，new.target会返回undefined，因此这个属性可以用来确定构造函数是怎么调用的。
类存在静态方法，使用static关键字表示，其只能类和继承的子类来进行调用，不能被实例调用，也就是不能被实例继承，所以我们称它为静态方法。类不存在内部方法和内部属性。
class Foo {
static classMethod() {
return 'hello';
}
}
Foo.classMethod() // 'hello'
var foo = new Foo();
foo.classMethod()
// TypeError: foo.classMethod is not a function
类通过extends关键字来实现继承，在继承的子类的构造函数里我们使用super关键字来表示对父类构造函数的引用；在静态方法里，super指向父类；在其它函数体内，super表示对父类原型属性的引用。其中super必须在子类的构造函数体内调用一次，因为我们需要调用时来绑定子类的元素对象，否则会报错。
class ColorPoint extends Point {
constructor(x, y, color) {
super(x, y); // 调用父类的constructor(x, y)
this.color = color;
}
toString() {
return this.color + ' ' + super.toString(); // 调用父类的toString()
}
}
