[详见demo 原型和继承 代码]
1、原型链继承：
- 核心： 子类原型设为父类实例化对象[在子类原型上增加了构造函数属性和方法，二级原型则是构造函数的原型内容]
- 优点： 方法复用，定义在父类原型上的方法可被子类复用；
- 缺点：
- 1.即父类构造函数属性和原型方法都设为了仅有一份的公有内容，不利于属性维护，违背了初衷
- 2.且子类实例化时不能为父类构造函数传参
- 3.不能实现多继承
- 4.修改了子类原型的constructor属性，需手动修正
// 定义子类构造函数
function A(name){
this.name=name||'父亲'
this.age=[1]
}
A.prototype.say=function(){
console.log('hello')
}
function B(name){
this.name=name
}
B.prototype=new A()
let b1=new B()
let b2=new B()
console.log(b1.name) //undefined 虽然原型里name是父亲，但是实例化对象的构造函数中声明了name变量，但是因为实例化B时没有传参数，所以是undefined
console.log(b1.age) //[1] 原型属性
b1.age.push(2) //实例对象修改了
console.log(b1)
console.log(b2)
构造函数继承
- 构造函数继承
- 在组合继承之前有个构造函数继承，就是使用在子类构造函数里使用call方法拷贝父类构造函数的属性和方法
- 优点：1.创建子类实例，可以向父类构造函数传参；
2.继承父类构造函数的引用属性为私有的；
- 缺点：1.不能复用父类原型方法
2、组合继承
- 核心：在子类构造函数里使用Parent.call(this,name),使得子类构造函数实例化对象时拥有独立的父类构造函数的属性，然后设置子类原型为父类实例对象，继承父类方法
- 优点：
- 1.创建子类实例，可以向父类构造函数传参；
- 2.继承父类构造函数的引用属性为私有的；
- 3.复用了父类原型方法
- 缺点：
- 1.拷贝了两次父类构造函数属性，多余1份；第1次继承的父类构造属性会被第2次继承的实力对象内的属性屏蔽掉，所以多余
- 2.需要修正constructor
// 定义父类构造函数
function Parent(name,arr){
this.name=name
this.age=[1]
}
// 定义父类原型方法
Parent.prototype.say=function(action){
console.log('hi')
}
let p=new Parent('王小二')
console.log(p,'p')
// 定义子类构造函数
function Son(name){
this.name=name
//核心：第2次继承 (此处为什么是第2次，因为js执行到Son函数体时没有执行到里面，而是先执行了new Parent()，再执行new Son()，此时才执行到Son函数)
//执行Parent函数，并将Parent函数的this指定为son函数的this，即实例化后的对象；
//相当于拷贝了一份Parent函数的内容（属性和方法）
Parent.call(this,name)
}
// 继承
Son.prototype=new Parent() //核心：第1次 继承了父类的构造函数的属性和原型方法
let son=new Son('li')
console.log(son,'son')
3-组合继承优化1
- 核心：在子类构造函数里使用Parent.call(this,name),使得子类构造函数实例化对象时拥有独立的父类构造函数的属性，然后设置子类原型为父类原型，继承父类方法
- 优点：
- 1.创建子类实例，可以向父类构造函数传参(call)；
- 2.继承父类构造函数的引用属性为私有的(call)；
- 3.复用了父类原型方法
- 缺点：1.需要修正constructor,而修正子类constructor后，父类constructor也被修改了
function Parent(name,arr){
this.name=name
this.age=[1]
}
Parent.prototype.say=function(action){
console.log('hi')
}
let p=new Parent('王小二')
console.log(p.constructor,'父类实例') // constructor是Parent，log里的对象状态是最终结果
// 定义子类构造函数
function Son(name){
this.name=name
//执行Parent函数，并将Parent函数的this指定为son函数的this，即实例化后的对象；
//相当于拷贝了一份Parent函数的内容（属性和方法）
Parent.call(this,name)
}
Son.prototype=Parent.prototype //核心： 继承了父类的原型对象，浅拷贝，两个对象引用同一内存地址，引发副作用
// 直接修改了子类原型，需要修正子类constructor，而修正子类constructor后，父类constructor也被修改了
let son=new Son('li')
console.log(son.constructor,'son') // constructor是Parent
Son.prototype.constructor=Son
// console.log(p.constructor,'修改constructor后的父类实例') // constructor是Parent
// console.log(son.constructor,'修改constructor后的son') // constructor是Parent
console.log(son,'son')
4-组合继承优化2(完美方法) ，又称Object.create()实现类式继承
在组合继承优化1里，因为浅拷贝，造成修改子类constructor后，父类该属性被同步修改了，故父类原型赋给子类原型时应该深拷贝，避免同步更新
- 核心：子类构造函数Parent.call(this,name),使得子类实例对象拥有独立的父类引用属性，然后父类原型赋给子类原型，继承原型方法，注意深拷贝
- 优点：
- 1.创建子类实例，可以向父类构造函数传参(call)；
- 2.继承父类构造函数的引用属性为私有的(call)；
- 3.复用了父类原型方法
- 4.修正子类constructor不影响父类
- 缺点：1.需要修正constructor
function Parent(name,arr){
this.name=name
this.age=[1]
}
Parent.prototype.say=function(action){
console.log('hi')
}
let p=new Parent('王小二')
console.log(p.constructor,'父类实例') // constructor是Parent，log里的对象状态是最终结果
// 定义子类构造函数
function Son(name){
this.name=name
//执行Parent函数，并将Parent函数的this指定为son函数的this，即实例化后的对象；
//相当于拷贝了一份Parent函数的内容（属性和方法）
Parent.call(this,name)
}
Son.prototype=Object.create(Parent.prototype) //核心： 将子类原型对象设为空对象，空对象原型是父类原型对象
// 直接修改了子类原型，需要修正子类constructor，而修正子类constructor后，父类constructor也被修改了
Son.prototype.constructor=Son
let son=new Son('li')
console.log(son,'son')
// Object.create(原型对象)
// Object.create(proto, [propertiesObject])
// 方法创建一个新对象，使用现有的对象来提供新创建的对象的proto，
// 是把现有对象的属性，挂到新建对象的原型上，新建对象为空对象
// 底层实现
// Object.create = function (o) {
// var F = function () {};
// F.prototype = o;
// return new F();
// };
