js之继承

js继承概念

js里常用的如下两种继承方式：
1.通过原型链方式实现继承（对象间的继承）
2. 类式继承（构造函数间的继承）

原型链

构造函数、原型、实例的关系：
每个构造函数都有一个原型对象（prototype），原型对象都包含一个指向构造函数的指针(constructor)，
而实例都包含一个指向原型对象的内部指针(__proto__)。

(每个对象都有一个内部属性__proto__属性,属性的值可以是一个对象,也可以是null.如果它的值是一个对象,则这个对象也一定有自己的原型.
这样就形成了一条线性的链,我们称之为原型链)

原型链继承

例子:
 function Parent() {
            this.hobby="play";
        }
        Parent.prototype.showHobby=function () {
            return this.hobby;
        }
        function Son() {
            this.sonhobby="eat";
        }
        //实现继承  ,继承Parent
        Son.prototype=new Parent();
        Son.prototype.showSonhobby=function () {
            return this.sonhobby;
        }
        var obj=new Son();
        alert(obj.showHobby())
        for(var i in obj){
            document.write(i+"---"+obj[i]+"<br>");
        }

原型链继承关系图

构造函数继承

function a(name,age){
			this.name=name;
			this.age=age;
			this.arr=['大哥','大姐','小姐姐'];
		}
		a.prototype.fun=function(){
			alert(this.name+this.age)
		}
		function b(name,age){
			a.call(this,name,age)
		}
		var b1=new b('jcak','12');
		var b3=new b('tom','122');
		var b2=new a();
//		alert(b1.name)//jack
//		alert(b2.name)//undefined
//		alert(b3.name)//tom
//		alert(b2.arr);//大哥,大姐,小姐姐
//		alert(b1.arr);//大哥,大姐,小姐姐
//		b1.arr.push('小哥哥');
//		alert(b2.arr);//大哥,大姐,小姐姐
//		alert(b1.arr);//大哥,大姐,小姐姐，小哥哥
		b1.fun()



//		var o={
//			x:4
//		}
//		var x=12;
//		function a(){
//			alert(this.x)//12  4
//		}
		window.a();
//		a.call(o)//o对象通过call方法冒充a来执行a里面的输出方法

组合继承

function a(name,age){
			this.name=name;
			this.age=age;
			this.arr=['哈哈','呵呵']
		}
		function b(name,age){
			a.call(this,name,age)
		}
		a.prototype.fun=function(){
			alert(this.name+this.age)
		}
		b.prototype=new a();
		var c1=new b('tom','12')
		var c2=new b('jack','122')
//		alert(c1.name)
//		alert(c2.name)
//		c1.fun();
//		c2.fun();
		alert(c1.arr)//哈哈，呵呵
		alert(c2.arr)//哈哈，呵呵
		c1.arr.push('嘿嘿')
		alert(c1.arr)哈哈，呵呵，嘿嘿
		alert(c2.arr)//哈哈，呵呵

总结

1：什么是继承，继承的概念：
	继承是指一个对象直接使用另一对象的属性和方法，继承可以使得子类具有父类的各种属性和方法。
2：继承的称呼：
	父类 == 超类型 == 基类
	子类 == 派生类
3：继承的方法：
	1：原型链继承
		原型链继承的缺点：
			1：创建子类实例时不能向超类传参
			2：引用类型不能保持独立
	2：构造继承
		借用构造函数的继承解决了：
			1：引用保持独立
			2：可以传参
			借用构造函数的继承（又叫：冒充继承）
			方法：call()
			构造继承缺点：
			对象冒充只能继承构造实例中的属性和方法，不能继承原型中的属性和方法！
	3：原型+构造继承（组合继承）
			组合继承就是   原型继承+构造继承
			原型链继承  只继承原型里面的内容
			构造函数（冒充继承）只继承构造函数里面的内容
			
			组合继承解决了  想共享的共享  不想共享的不共享问题