js继承与多态

原型链：多个对象的原型互相调用形成的链式结构
函数有prototype
任何东西都有_proto_


最简单的
子函数的原型=父元素的实例
Call和apply的区别  前者是直接传参  后者是传数组
Call和apply的效果  改变其他函数内部的this指向

完全继承
//要复制的函数原型
function add(a,b){
    return a+b;
}
(function(){
    function obj(fn, newfn, obj){}
    obj.prototype=fn.prototype;
    newfn.prototype=new obj();
})();

//函数嵌套，call和apply三个改变this的指向，一般this指向window/调用对象/new出来的对象
			function parent(oName){
				this.name=oName||'Jack';
				this.skill=function(){
					console.log('inner');
				}
			}
			parent.prototype.skill=function(){
				console.log('swimming');
			}
			var obj=new parent();
			console.log(obj.skill()+'AAAAAAAAAAAAAA');
			function son(){}
			son.prototype=new parent();//继承父元素，不使用直接相等parent.prototype，因为会改变父亲原型
			son.skill=function(){
				console.log('sonsskill');
			}
			var Son=new son();
			console.log(Son.skill()+'BBBBBBBBBBBBBB');

//工厂方法造人
			function createman(Name,Age){
				var obj={};
				obj.name=Name;
				obj.age=Age;
				obj.skill=function(){
					alert(this.name);//this指代刚产生的对象
				}
				alert(this);//若不是new方法，则指向window
				return obj;
			}
			var li=createman('liming','20');
			var sun=createman('sunhong','20');
			
			
			//工厂方法进化成构造函数造人，不用return，构造函数也可以称为类
			function Createman(Name,Age){
				this.name=Name;
				this.age=Age;
				this.skill=function(){
					alert(this.name);//this指代刚产生的对象
				}
				alert(this);//指向new出来的新对象
			}
			var Li=new Createman('liming','20');//构造函数的实例
			var Sun=new Createman('sunhong','20');
			Createman.prototype.jineng=function(){//原型上的方法容易被覆盖
				alert(this.age);
			}
			alert(Li.jineng==Sun.jineng);//true

function add(a,b){
				
				this.age='12';
				this.sex='male';
				console.log(this+'add里边的');//this指向了jian对象，因为是jian调用了它
				return a+b;
			}
			function jian(a,b){
				var sum=add.call(this,a,b);//this还是指向new出来的oJian
//				var sum=add.apply(this,[a,b]);与上边区别就是参数是数组
//				call和apply无法取到原型的方法
				this.name=sum;//this指向new出来的oJian
			}
			var oJian=new jian(1,2);
			console.log(oJian.name+'name');
			console.log(oJian.sex+'sex');