Javascript面对对象. 第五篇

继承

继承是面向对象中一个核心的概念。其他正统面向对象语言都会用两种方式实现继承：

一个是接口实现，一个是继承。

而ECMAScript只支持继承,不支持接口实现，而实现继承的方式依靠原型链完成。

//继承，通过原型链实现
	function Box(){  //被继承的函数叫超类型(父类，基类)
    		this.name="link"
    	}
   	function Dest(){//继承的函数叫子类型(子类，派生类)
    		this.age=25;
    }
    	function Table(){
   		this.level="dfsfsdf";
    }
   	//通过原型链继承，超类型实例化后的对象实例，赋值给予类型的原型属性
    	//new Box()会将Box构造里的信息和原型里的信息都提交给Dest
    	Dest.prototype=new Box();
    	Table.prototype=new Dest();
		var dest=new Dest();
   	alert(dest.age)
   	alert(dest.name)

   	var table=new Dest();
   	alert(table.age)
   	alert(table.name)

如果要实例化Dest,那么Box实例中的name="link",原型中添加相同的属性name="xiao",如果有Box有就是link,没有就是xiao

//继承，通过原型链实现
      	function Box(){  //被继承的函数叫超类型(父类，基类)
      		//this.name="link"
      	}
      	Box.prototype.name="xiao";
      	function Dest(){//继承的函数叫子类型(子类，派生类)
      		this.age=25;
      }

      	//通过原型链继承，超类型实例化后的对象实例，赋值给予类型的原型属性
      	//new Box()会将Box构造里的信息和原型里的信息都提交给Dest
      	Dest.prototype=new Box();
      		var dest=new Dest();
      	alert(dest.age)
      	alert(dest.name)  //xiao

ps:以上原型链继承还少一环，那就是Object,所有的构造函数都继承自Object。而继承object是自动完成的，并不需要程序员手动继承。

//经过继承后的实例，他们的从属关系会是什么？
			alert(table instanceof Object);   //true
			alert(dest instanceof Table);      //false，dest是Table的超类
			alert(table instanceof Dest);    //true
			alert(table instanceof Box);     //true

在javascript里，被继承的函数称为超类型(父类，基类)，继承的函数称为子类型(子类,派生类)。继承也有之前的问题比如字面量重写原型会中断关系，使用引用类型的原型,并且子类型还无法给超类型传递参数。

为了解决共享和超类型无法传参的问题,我们采用了一种叫借用构造函数的技术,或者成为对象冒充(伪造对象,经典继承)的技术来解决这两种问题。

	//使用对象冒充
		function Box(name,age){
			this.name=name;
			this.age=age;
			this.family=['哥哥','妹妹','弟弟']  //引用类型,放在构造里就不会共享。
		}
		//Box.prototype.family='姐姐';

		function Dest(name,age){
			Box.call(this,name,age)   //对象冒充，对象冒充只能继承构造里的信息
		}
		var dest=new Dest('link',111);
		dest.family.push('姐姐');
		alert(dest.name);
		alert(dest.family);

		var dest2=new Dest('html',111);
		alert(dest2.family);

借用构造函数虽然解决了刚才两种问题，但是没有原型，复用则无从谈起。所以，我们需要原型链+借用构造函数的模式，这种模式成为组合继承。

    function Box(name,age){
			this.name=name;
			this.age=age;
			this.family=['哥哥','妹妹','弟弟']  //引用类型,放在构造里就不会共享。
		}
		Box.prototype.run=function(){
			return this.name+this.age+"运行中...";
		}
		//构造函数里的方法，放在构造里，每次实例化，都会分配一个内存地址，浪费，所以最好放到原型里，保证多次实例化只有一个地址。
		function Dest(name,age){
			Box.call(this,name,age)   //对象冒充，对象冒充只能继承构造里的信息
		}

		Dest.prototype=new Box();   //原型链继承

		var dest=new Dest('link',111);
		alert(dest.run());

还有一种继承模式叫：原型式继承：这种继承借助原型并基于已有的对象创建对象，同时还不必因此创建自定义类型。

我们学习过：
1.原型链继承，2.借用构造函数继承(对象冒充继承)3.组合继承(结合前俩种)

4.原型式继承

//4.原型式继承

		//临时中转函数
		function obj(o){    //o表示将要传递进入的一个对象
			function F(){}   //F构造是一个临时新建的对象，用来存储传递过来的对象
			F.prototype=o;   //将o对象实例赋值给F构造的原型对象
			return new F(); //最后返回这个得到传递过来对象的对象实例
		}

		//F.prototype=o 其实就是相当于Dest.prototype=new Box();

		//这个字面量的声明方式，相当于var box=new Box();
		var box={
			name:'link',
			age:23,
			family:['哥哥','妹妹','弟弟']
		}
		//box1等于new F();
		var box1=obj(box);
		alert(box1.name);
		alert(box1.family);
		box.family.push('姐姐');
		alert(box1.family);

		var box2=obj(box);
		alert(box2.family);

5.寄生式继承=原型式+工厂模式

//临时中转函数
		function obj(o){
		   function F(){}
		   F.prototype=o;
		   return new F();
		}
		//寄生函数
		function  create(o){
			var f=obj(o);
			return f;
		}
		var box={
			name:'link',
			age:23,
			family:['哥哥','妹妹','弟弟']
		}

		var box1=new create(box);
		alert(box1.name);

//临时中转函数
		function obj(o){
		   function F(){}
		   F.prototype=o;
		   return new F();
		}
		//寄生函数
		function  create(box,dest){
			var f=obj(box.prototype);
			f.constructor=dest;   //指向了Dest,没有是话指向Box
			dest.prototype=f;

		}
		function Box(name,age){
			this.name=name;
			this.age=age;
		}
		Box.prototype.run=function(){
			return this.name+this.age+"运行中。。。";
		}
		function Dest(name,age){
			Box.call(this,name,age)
		}
		//通过寄生组合继承来实现继承
		create(Box,Dest);   //这句话用来替代Dest.prototype=new Box();

		var dest=new Dest('link',23);
		alert(dest.run());
		alert(dest.constructor);