javascript中实现继承的三种方式：原型继承、借用构造函数继承、混合继承：
/*
js当中的继承 js中 构造函数 原型对象 实力对象的关系：
1 构造函数.prototype = 原型对象
2 原型对象.constructor = 构造函数（模板）
3 原型对象.isPrototypeOf(实例对象) 判断实例对象的原型是不是当前对象
4 构造函数 实力对象 是 类和对象的关系
*/ /*
1 原型继承
给子类构造函数的原型对象赋值为父类构造函数的实例
赋值之后产生的关系：
1 子类的原型对象是父类的一个实例 Son.prototype 是 new Father()
2 父类的方法和属性，子类可以在原型中得到
3 子类的原型对象的构造器是父类模板 Son.prototype.constructor 是 Father
4 子类的原型对象的原型对象是父类的原型对象 Son.prototype.prototype 是Father.prototype
原型继承的特点：
子类继承了父类所有属性方法发和 父类原型对象中的属性和方法
缺点： 不能在子类实例化对象的时候给父类的属性赋值，继承父类的值和子类对象实例化分开了。
*/ //父类构造函数
function Father(name){
this.name = name;
}
//父类原型对象
Father.prototype={
constructor: Father,
id:10,
sayName:function(){
alert(this.name);
}
}; //子类构造函数
function Son(age){
this.age = age;
}
//子类原型对象 这一家子都姓张
Son.prototype = new Father("张"); //子类的实例 能够使用父类的属性和方法
var s1 = new Son(18);
//s1.sayName(); //张
//alert(s1.age); //18 /*
原型继承的特点：
子类继承了父类所有属性方法发和 父类原型对象中的属性和方法
缺点： 不能在子类实例化对象的时候给父类的属性赋值，继承父类的值和子类对象实例化分开了。
*/ /*
2 类继承（借用构造函数） 只继承父类的构造函数，父类的原型对象没有继承过来
利用call 或者apply进行函数绑定，借用父类构造函数的属性和方法
*/
//父类构造函数
function Father(name){
this.name = name;
}
//父类原型对象 在子类中不能继承父类原型对象中的内容
Father.prototype.id = 10; //子类构造函数
function Son(name,age){
//name属性是父类的 不是子类的 借用父类的构造函数 把属性绑定给子类的实例对象
Father.call(this,name);
this.age = age;
}
//实例化子类对象 在这里可以直接给继承来的属性赋值
var s2 = new Son("z3",18);
//alert(s2.name); //z3 父类构造函数绑定来的属性
//alert(s2.age); //18 子类自己的属性 /*
类继承（借用构造函数） 的特点：
优点： 能够在实例化子类对象时候给继承父类的属性赋值
缺点：父类的原型对象中的内容无法继承
*/ /*
3 混合继承：原型继承 和 借用构造函数继承 的混合
特点：
优点：1 能够在实例化子类对象的时候给继承来的属性赋值
2 能够继承父类的原型对象中的方法
缺点： 继承了两次父类的模版，分别是call绑定和子类原型对象赋值的时候
如果继承来的属性特别多，这会很耗费时间来维护
*/
//父类
function Father(name){
this.name = name;
}
//父类的原型对象
Father.prototype = {
constructor:Father,
id:10,
sayName:function(){
alert(this.name);
}
};
//子类
function Son(name,age){
//借用父类构造函数 绑定子类方法 为子类继承来的属性赋值
Father.call(this,name);
this.age = age;
}
//原型继承 不传递参数，继承自父类的属性赋值交给借用父类构造函数去做
Son.prototype = new Father(); //使用子类实例化对象
var s3 = new Son("l4",20);
//alert(s3.name); //父类属性
//alert(s3.id); //父类原型对象的属性
//alert(s3.age); //自己的属性
//s3.sayName(); //父类原型对象中的方法
/*
混合集成的特点：
优点：1 能够在实例化子类对象的时候给继承来的属性赋值
2 能够继承父类的原型对象中的方法
缺点： 继承了两次父类的模版，分别是call绑定和子类原型对象赋值的时候
如果继承来的属性特别多，这会很耗费时间来维护
*/
但是 上面三种方式 即使是混合继承也有弊端，下面用js模拟一下extends的继承方，来实现不会重复继承父类的构造函数：
/*
javascript模拟extends方法，
目的：
1子类实例化能够赋值继承来的属性
2 继承父类的原型对象
3 父类的构造函数只继承一次
*/ //1 我们模拟一个extends函数 用于实现类之间的继承 传入父类和子类
function extend(son,father){
//让子类继承父类的原型而不继承父类构造函数的内容
var f = new Function(); //临时空函数，目的是函数内部是空的 但是原型是父类的原型
f.prototype = father.prototype; //让空函数的原型指向父类的原型
son.prototype = new f(); //让子类的原型指向一个空函数，空函数的原型是父类的原型，这就避免了父类构造函数的属性被重复实现
//给子类添加一个superClass属性保存父类的原型对象，防止自己重写了父类方法后 无法调用父类原型对象中的方法
son.superClass = father.prototype;
//为父类原型对象添加构造器 如果父类原型对象忘记加构造器这里给他加上
if(father.prototype.constructor == Object.prototype.constructor){
father.prototype.constructor = father;
}
}
//2 父类
function Father(name){
this.name = name;
}
//父类的原型对象
Father.prototype = {
constructor: Father,
sayName:function(){
alert(this.name);
}
}; //3 子类
function Son(name,age){
//借用构造函数：为子类绑定父类的构造函数中属性
// Father.call(this , name); 这里不这样写，为了解耦，增加通用性，经过extentds函数之后，子类里面有了父类的属性
Son.superClass.constructor.call(this , name); //Son.superClass是父类的原型对象，consturctor就是父类构造函数
this.age = age;
}
//原型继承
//Son.prototype = new Father(); //会再次绑定一次父类的构造函数 ，这里为了不重复继承父类构造函数，只继承父类原型对象 我们用自己
//调用自己的继承方法 实现为子类继承父类的原型对象 而不继承父类的构造函数 extend(Son,Father); //使用子类
var s4 = new Son("haha",33);
alert(s4.name); //haha 父类继承来的属性
alert(s4.age); //33 自己的属性
s4.sayName(); //haha 父类继承来的方法
//重写父类方法
s4.sayName = function(){
alert("hello i am son");
};
s4.sayName(); //hello i am son 重写方法覆盖了父类的sayName
//重写之后还想调用父类的方法 需要绑定一下 指定是我这个对象来调用
Son.superClass.sayName.call(s4); //haha