通过上一篇文章想必各位老铁已经熟悉了class了，这篇文章接着介绍继承。面向对象里最大的特点应该就属继承了。一个项目可能需要不断的迭代、完善、升级。那每一次的更新你是要重新写呢，还是在原有的基础上改吧改吧呢？当然，不是缺心眼的人肯定都会在原来的基础上改吧改吧，那这个改吧改吧就需要用到继承了。
在第二篇文章里说过原型实例跟构造函数之间的继承，并且还讲了一道推算题。最终我们明白，实例为什么能继承原型上的内容是因为prototype，所以在ES5里面想要继承的话就得通过原型，需要对prototype进行一顿蹂躏才行。那到了ES6里面一切就简单了，像开了挂似的！so easy，哪里不会点哪里！
继承
- class类可以通过extends实现继承
- 利用super关键字引入父类的构造函数
- ES6规定子类必需在构造函数（constructor）里先调用super方法
- 子类能同时继承父类的共享方法与私有方法
//这个类做为父类('老王')
class OldWang{
constructor(work,money){
this.work=work;
this.money=money;
}
showWork(){
console.log(`老王是个${this.work}，看了我的文章后，能力达到了${this.level}，一个月能挣${this.money}元`);
}
static play(){ //这是个私有方法，但子类依然能继承到
console.log('大吉大利，今晚吃鸡！不会玩游戏的前端不是个好前端！');
}
}
//子类继承父类
class SmallWang extends OldWang{
constructor(work,money,level){
//这里必需先写super，不然会报错
super(work,money,level);
this.level=level; //只有用了super，才能使用this
}
}
//生成实例
const wang=new SmallWang('前端',20000,'T5');
wang.showWork(); //老王是个前端，看了我的文章后，能力达到了T5，一个月能挣20000元
SmallWang.play(); //大吉大利，今晚吃鸡！不会玩游戏的前端不是个好前端！ 子类能继承父类的私有方法
//与ES5里的实例是一致的
console.log(
Object.getPrototypeOf(SmallWang)===OldWang, //true 子类的原型是OldWang，也就是说，它是OldWang的实例
wang instanceof OldWang, //true
wang instanceof SmallWang, //true
);
ES5的继承，实质是先声明子类，然后通过call方法将父类的方法添加到子类上，而ES6的继承机制完全不同。实质是声明了子类后，子类并没有this对象，而是利用super方法引入父类的this对象，再将this修改成子类，就这么神奇！
new.target
new是生成实例的命令。ES6为new命令引入了一个new.target属性，该属性一般用在构造函数之中
new.target返回new命令作用于的那个类- 子类继承父类时，
new.target返回子类
class Person{
constructor(){
//如果类不是通过new调用的，就会返回undefined
if(new.target===undefined){
throw new Error('请使用new生成实例！');
}
console.log(new.target.name);
}
}
new Person(); //Person类(返回了new作用于的那个类)
Person(); //有些浏览器可以不带new生成实例，就会抛出一个错误
class Man extends Person{
}
new Man(); //Man（子类继承父类时，new.target会返回子类）
//利用这个特性实现一个不能独立使用，必需继承后才能用的类（像React里的组件）
class Uncle{
constructor(){
if(new.target===Uncle){
throw new Error('这个类不能实例化，只能继承后再用');
}
}
showUncle(){
console.log('都是他舅');
}
}
//new Uncle(); 报错
//通过继承就可以使用Uncle了
class BigUncle extends Uncle{
constructor(){
super(); //引入父类的构造函数，必须加不然报错
this.uncle='他大舅';
}
}
//实例
const uncle=new BigUncle();
uncle.showUncle(); //都是他舅
原型
class里的原型关系相对于ES5里的原型关系，ES6对其进行了修改，但只修改了子类与父类之间的关系，其它的关系并没有修改。
- 子类的
__proto__，表示构造函数的继承，指向父类构造函数- 子类prototype属性的
__proto__，表示方法的继承，指向父类的prototype
ES5里的继承关系，在第二篇文章里详细介绍过，再回顾一下：
//ES5的继承关系
const str=new String(123);
console.log(
str.__proto__===String.prototype， //true
String.__proto__===Function.prototype //true
);
//可以看到不管实例还是构造函数，它们的__proto__属性永远都指向原型
ES6与ES5的对比如下：
//ES5
function Ball(){}
function Football(){
Ball.call(this); //ES5的继承
}
//ES6
class Father{};
class Son extends Father{}
//构造函数，关系没变
console.log(
'构造函数',
Ball.__proto__===Ball.prototype, //false
Father.__proto__===Father.prototype,//false
Ball.__proto__===Function.prototype, //true
Father.__proto__===Function.prototype //true
);
//实例，关系没变
console.log(
'实例',
new Ball().__proto__===Ball.prototype, //true
new Father().__proto__===Father.prototype //true
);
//子类，关系变了
console.log(
'子类的__proto__',
Football.__proto__===Ball, //false ES5
Football.__proto__===Function.prototype,//true ES5
Son.__proto__===Father, //true ES6
Son.__proto__===Father.prototype, //false ES6
//ES6的变化为：子类的__proto__指向父类
);
console.log(
'子类的prototype的__proto__属性',
Football.prototype.__proto__===Ball.prototype, //false ES5
Football.prototype.__proto__===Object.prototype,//true ESS
Son.prototype.__proto__===Object.prototype, //false ES6
Son.prototype.__proto__===Father.prototype, //true ES6
//ES6的变化为：子类的prototype的__proto__属性指向父类的prototype
);
由此可以看出ES6只修改了子类跟父类间的原型关系，其它的不受影响。那至于ES6对这两条关系做了修改的原因跟ES6的继承机制有关系，ES6内部的继承用的是Object.setPrototypeOf方法（ES6新增的方法，作用是把第一个参数的原型设置成第二个参数），以下为内部过程：
{
class Father{};
class Son{};
//son的实例继承Father的实例，内部会执行下面的代码
Object.setPrototypeOf(Son.prototype,Father.prototype);
//等同于Son.prototype.__proto__=Father.prototype;所以得出结果：子类prototype属性的__proto__属性，表示方法的继承，指向父类的prototype属性
//son继承Father的私有属性，内部会执行下面的代码
Object.setPrototypeOf(Son,Father);
//等同于Son.__proto__=Father;所以得出结果：子类的__proto__属性，表示构造函数的继承，指向父类
}
为什么用了setPrototypeOf后，等价于把第一个参数的__proto__的值设置成第二个参数？是因为setPrototypeOf方法的内部是这样的：
//setPrototypeOf方法内部主要代码
Object.setPrototypeOf=function(obj,proto){
obj.__proto__=proto;
return obj;
}
下一篇文章介绍super关键字
