ES6之前的4种继承方法

<script type="text/javascript">

// 1.使用call（）或则apply（）方法达到继承效果

// 汽车例子：
// 使用call（）方法达到继承效果：需要把实参按照形参的个数传进去

   function Wheel(wheelSize,style){
			this.wheelSize = wheelSize;
			this.style = style;
		}
	function Sit(c,sitColor){
			this.c= c;
			this.sitColor =sitColor;
		}
	function Model(height,width){
			this.height= height;
			this.width =width;
		}
   function Car(wheelSize,style,c,sitColor,height,width){
      	Wheel.call(this,wheelSize,style);//如果写成Wheel.(this,wheelSize,style);这里的this指向的是window对象，call（）方法使this指针指向了Wheel这个函数，下面同理
		Sit.call(this,c,sitColor);
		Model.call(this,height,width);
   }

   var car = new Car(100,
   	"彩色的黑","5","白色",1800,1900);
   console.log(car)

    //使用apply（）方法达到继承效果：
   function Person(){
   	this.name = arguments[0];
   	this.age = arguments[1];
   	this.sex = arguments[2];
   	this.tel = arguments[3];
   }
   function Student(name,age,sex,tel){
   	Person.apply(this,[name,age,sex,tel]);//使用apply方法需要在被继承的方法里面搭配argumen使用，并且需要注意实参和形参的顺序不能乱，并且传的是数组
   }
   var stu = new Student("Merry",25,"male",110);
		console.log(stu.name,//Merry
					stu.age,//
					stu.sex,
					stu.tel
			);

总结：call 和 apply的作用是一样的，只不过传参方式不一样。两者都必须使用new的创建才有有效

2.两种类型之间的继承 – 原型继承模式 继承者的修改会影响到父类型的结构

 function Father(){

   }
   Father.prototype.name = 'summy';
   function Son(){

   }
   // 让Father函数的原型也变成Son函数的原型
   Son.prototype = Father.prototype;
   Son.prototype.sex = "male";//这样的修改会影响父原型
   var s = new Son();
   var f = new Father();
   
   console.log(s.sex);
   console.log(f.sex);

3.圣杯模式的方法：

 function inherit(Traget,Origin){
       function F(){}
       F.prototype = Origin.prototype;
       Traget.prototype = new F();
       //此时修改Traget的构造函数Origin，，按理说应该是Traget
       //修改：
       Traget.prototype.constructor = Traget;
       //可选项的完善 想记录Traget真实继承至谁
       Traget.prototype.ubr = Origin.prototype;
   }
   inherit(Son, Father);
   var s = new Son();

4.最原始的继承 缺点：会过多的继承没有用的属性

  

Grand.prototype.lastName = "jack";
	function Grand(){//构造函数用来创建对象，工厂

	}
	var grand = new Grand();
	Father.prototype = grand;
	function Father(){
		this.name = "小明";
		this.cars = {
			car1:"BWM",
			car2:"Infiniti"
		};
		this.num = 100;
	}

	var father = new Father();

	Son.prototype  = father;
	function Son(){
		this.hobbit = "running"
	}

	var son = new Son();
	// 试图修改父中的属性，并且属性为基本数据类型  结果：并没有修改父中的属性，而是在子中添加了一个属于自己的name属性
	son.name  = "小华";
	// 修改构造函数中的引用值，--》等用于修改了父中的内容  
	son.cars.car2="兰博基尼";
	son.num++;
	console.log(father.num);//100
	console.log(son.num);//101
	</script>