1.原型和原型链的继承：
优点：实例是子类的实例，也是父类的实例。父类新增的属性和方法子类都可以访问。
缺点：原型的属性是共享的修改一个属性所有的属性都改变了。创建子类没法向父传参。
//原型和原型链继承
function Par(){
this.a = true;
this.info={
name:"xiaoming",
age:20
}
}
Par.prototype.getInfo=function(){
console.log("父"+ this.info,this.a);
}
function Chi(){}
//父的实例赋值给子类的原型
Chi.prototype = new Par();
let one = new Chi();
console.log(one.info.name); //xiaoming
one.getInfo();
2.构造函数继承：子类构造函数内部调用父类构造函数。使用call/apply将父类的构造函数绑定在子对象上。
优点：子类实例共享引用属性的问题。子类可向父类传参。
缺点：每个子类对象都有自己的执行函数，如果对象多了，内存消耗大。
//构造函数继承
function Parent(msg){
this.info={
name:"aa",
age:10,
msg:msg
}
}
function Child(msg){
this.test="child" //子类属性
Parent.call(this,msg);//继承的体现
}
let a = new Child("参数");
console.log(a.info.name); //aa
3.组合式继承：
原型链继承和构造函数式继承组合
优点：不存在引用属性共享的问题。子类可向父类传递参数。
缺点：子类原型上多余了一份父类的实例。
//组合式继承
function Parent(msg){
this.info={
name:"zhaomi",
age:18,
msg:msg
}
}
Parent.prototype.getInfo=function(){
console.log("原型值"+this.info.name); //zhaomi
console.log(this.info);
}
function Child(msg){
//构造函数继承
Parent.call(this,msg);
}
Child.prototype = new Parent();
let a = new Child("组合式");
console.log(a.getInfo());
4.原型式继承：有一个封装继承过程的函数，用来增强对象的。
优点：不需要单独创建构造函数
缺点：属性会在对象中共享，子类实例不能向父类传参。
//原型式继承
//在构造函数a内部创造一个临时的构造函数B
//a的参数是一个对象，将a的参数绑定在b的原型上，返回一个b的实例。
function creObj(obj){
//1.创建一个临时的构造函数
function Fun(){}
//2.obj绑定到Fun的原型上
Fun.prototype = obj
//3.返回Fun的一个实例
return new Fun()
}
let person = {
name:"zhangmi",
age:20,
like:['骑行','探险'],
showInfo(){
console.log(1,this.name);
}
}
//测试：
let one = new creObj(person);
one.name = "lili";
console.log(2,one); //lili
one.like.push('游泳');
console.log(3,one.like);//['骑行','探险','游泳']
5.寄生式继承：创建对象的方法，封装创建过程的函数，实际的对象
优点：不需要单独创建构造函数
缺点：代码复用性比较差，编写起来比较复杂。
//寄生式继承
//创建对象
function objCopy(obj){
function Fun(){}
Fun.prototype = obj;
return new Fun();
}
//封装过程的函数
function creAno(obj){
//原型式继承
let clone = objCopy(obj);
clone.showName = function(){
console.log(this.name);
}
return clone;
}
let person = {
name:"周周",
age:19,
like:["爱好","爱好1"]
}
let one = creAno(person);
one.like.push("爱好2"); //['爱好', '爱好1', '爱好2']
console.log(one.like);
6.es6中的继承：extends实现继承的
//es6继承
class Parent{
constructor(name){
this.name = name;
this.arr=[1,2,3];
}
}
class Child extends Parent{
constructor(){
super("父级");
this.name ="小小";
}
}
let ar1 = new Child();
let ar2 = new Child();
console.log(ar1,ar2);
