先说一个有关面向对象的小知识点有助于大家对后面理解
1.每个构造函数都有一个原型对象(prototype).
//即每一个构造函数有一个prototype属性，prototype指向原型对象
//原型对象的所有属性和方法都会被构造函数的实例继承.
2.原型对象(prototype)都包含一个构造函数指针(constructor).
//prototype就是通过constructor指向Object的.
3.实例都包含一个指向原型对象的内部指针(_proto_).
//_proto_是查找函数或对象的原型链的方式.
这些都是为了让大家稍微有一些了解，ok，进入正文。
首先，本篇简书关于JS继承的，我把关于JS继承分为3种方法和两种优化：
1.盗用构造函数继承
2.原型链式继承
3.组合式继承
组合式继承中包含了两个优化
方法1：盗用构造函数继承
function Father1(){
this.father_Property1 = "父类属性1"
this.father_Property2 = "父类属性2"
}
function Son1(){
Father1.call(this);//或apply
}
new Son1().father_Property1;
new Son1().father_Property2;
先看第五行，这句话的意思，大家就可以理解为，Son1把Father1叫了过来，对他说：你就是我爸爸！我要继承你的属性！没错，大家就可以简单粗暴的这样理解，很通俗易懂。第六行，子类自己定义了一个属于自己的属性(没啥用~)
console.log(new Son1().father_Property1)//父类属性1
console.log(new Son1().father_Property2)//父类属性2
到这里都没问题，子类Son1成功继承了父类Father1中的父类属性1和父类属性2
在接着往下看
Father1.prototype.father_Property3 = "父类原型上的属性3"
Father1.prototype.father_Property4 = function(){
console.log("父类原型上的属性4")
}
new Son1().father_Property3;
new Son1().father_Property4;
console.log(new Son1().father_Property3)//undefined
console.log(new Son1().father_Property4)//undefined
到这里就出问题了，Son1并没有继承Father1原型对象上的属性3、4。
我们可以这样理解，不在原型链上的父类属性也就是我们之前可以继承的父类属性1、2，他就相当于父类的肤色，身高，他的子类是可以继承的。但是！！！父类原型(重点是父类原型)上的属性3、4，就相当于父类的第三个孩子和第四个孩子，那么第一个孩子能管第三个孩子和第四个孩子叫儿子吗？
答案显而易见，所以用构造函数实现继承时，子类无法继承父类原型上的属性。
方法2：原型链式继承
function Father1(){
this.father_Property1 = "父类属性1"
this.father_Property2 = "父类属性2"
}
function Son1(){
}
为了让大家更容易理解，我还是用的Father1和Son1，大家可以发现，原型链继承与构造函数继承很明显的区别，就是这次，我们在Son1里面没有“认爹”这一步，接着看：
Son1.prototype = new Father1()
Father1.prototype.father_Property3 = "父类属性3"
console.log(new Son1().father_Property3)//"父类属性3"
我们直接把Son1的原型对象指向Father1，之后虽然Father1又新定义了属性3，但是我们通过Son1调用之后还是可以使用，这就是我们和第一种方法最明显的优点，就是即使是在父类原型上定义的属性，作为子类，我们依然可以调用！
第二种方法还是有问题
如下
var s1 = new Son1()
s1.father_Property1.push("新推入的属性")
console.log(s1.father_Property1) ["父类属性10", "父类属性11", "父类属性12", "新推入的属性"]
var s2 =new Son1();
console.log(s2.father_Property1) ["父类属性10", "父类属性11", "父类属性12", "新推入的属性"]
(提个小知识点，就是.push只能往数组里面推入数据，而不能往字符串里面推入数据。)
可以看到我们只单单向S1调用的父类属性1中推入了一个新数据，并没有对S2进行任何操作，但是当我们打印S2的时候，他也被推入了一个新的数据，也就是说，原型链继承方法虽然可以解决“子类无法继承父类原型上的属性”这个问题，但是却出现了他可以更改父类原型问题。这是因为数组相当于是引用类型，保存在原型上，而name等属性属于原始类型，保存在实例中，每个实例都用不同的属性，互不影响，也就是说，只有引用值类型会影响原型链继承。
方法3：组合式继承
function Father1(){
this.father_Property1 = ["父类属性01","父类属性02","父类属性03"]
this.father_Property2 = "父类属性2"
}
function Son1(){
Father1.call(this);//或apply
}
Son1.prototype = new Father1();
Father1.call(this);
Son1.prototype = new Father1();
组合式继承，把我们以上两种继承方法的有点结合起来（也“认爹”了，也指定原型对象了）
var s1 = new Son1()
s1.father_Property1.push("新推入的属性")
console.log(s1.father_Property1)["父类属性01", "父类属性02", "父类属性03", "新推入的属性"]
var s2 =new Son1();
console.log(s2.father_Property1) ["父类属性01", "父类属性02", "父类属性03"]
ok,问题解决
接下来进行优化
我们现在用的这种方法，父类的构造函数是被执行了两次的，第一次：Son1.prototype = new Father1();第二次：实例化的时候会被执行
优化1：
function Father1(){
this.father_Property1 = ["父类属性01","父类属性02","父类属性03"]
this.father_Property2 = "父类属性2"
}
function Son1(){
Father1.call(this);//或apply
}
Son1.prototype = Father1.prototype;
Son1.prototype = new prototype();直接把父类的原型对象赋给子类的原型对象，这样，父类的构造函数就仅仅被执行了一次，优化OK~
还有一个问题，如下
var s1 =new Son1();
var s2 =new Son1();
console.log(s1 instanceof Son1) //true
console.log(s1 instanceof Father1) //true
我们要想区分s1到底是由Son1实例化还是由Father1实例化，运用instanceof后发现全是true，所以我们无法判断到底是由谁进行实例化的，换一种方法试验一下：
console.log(s1.constructor.name); //Father1
凉凉，明明由Son1实例化，却指向了Father1。
这是因为Son1.prototype = Father1.prototype;不仅仅将Son1继承了Father1，同事还使Son1的实例化对象也指向了Father1。这不是我们想看到的。
优化2：最终优化：
function Father1(){
this.father_Property1 = ["父类属性01","父类属性02","父类属性03"]
this.father_Property2 = "父类属性2"
}
function Son1(){
Father1.call(this);//或apply
}
Son1.prototype = Object.create(Father1.prototype);
Son1.prototype.constructor = Son1;
Object.create是一种创建对象的方式
1.方法内部定义一个新的空对象obj
2.将obj._proto _的对象指向传入的参数proto
3.返回一个新的对象
var s1 =new Son1();
var s2 =new Son1();
console.log(s1 instanceof Son1) //true
console.log(s1 instanceof Father1) //true
console.log(s1.constructor.name); //Son1
