【JavaScript高级程序设计】对象的创建与继承

关于JS面向对象的部分中，关于对象的创建和继承的各种方法，以及这些方法之间的区别和适用场景是经常被问到的。

首先，关于 对象的创建。
1.最简单的方法，大括号创建，var o = {}；或者是用对象字面量方法，var 0 = {name:"jack",age = 10};
问题：当使用相同接口创建很多对象时，会产生大量重复的代码。

2.工厂模式方法：将创建对象的细节封装起来，这样可以解决创建多个相似对象的问题。

	function createA(){
		var o = new Object();
		o.name = "jack";
		o.age = 10;
		return o;
	}
		var A = createA();

问题：带来了对象识别问题，不能知道一个对象的类型。也就是说用instansOf()方法无法确定对象的类型。
注意：不能用new来调用创建对象的函数，并且在函数的内部要返回那个Object对象。
3.构造函数方法

function Person(name,age){
		this.name = name;
		this.age = age;
		this.sayName = function (){
			alert(this.name);
		}
	}
		var person = new Person("jack",10);

通过检查实例的constructor属性，或者使用instanceof()方法可以确定对象的类型。
问题：每个方法都要在每个实例上创建；
            创建多个完成相同任务的Function实例是没必要的。
            如果把这样的Funtion从构造函数中移除来，则函数会变成为全局环境中的成员，破坏了封装性。
4.原型模式
原型:是指向一个对象的，这个对象包含由所有实例共享的方法和属性。     

	function Person(){


		}
		Person.prototype.name = "jack";
		Person.prototype.age = 10;
		Person.prototype.sayName = function (){
			alert(this.name);
		}
	var wang = new Person();

注意：所有的实例保存的仅是指向对象原型的指针。所有实例共享原型的属性和方法。实例可以重写属性，覆盖原型对象中的相同属性，但是并不改变原型中的这个属性。
可以使用hasOwnPropertyp()来判断，当属性存在于对象中时返回true。if (wang.hasOwnProperty("name")) {alert(true);}
比如:

	var wang = new Person();
	console.log(wang.age); //10
	wang.age = 20;
	console.log(wang.age); //20
	var li = new Person();
	console.log(li.age);   //10

问题：省略了为构造函数传参，所有实例在默认情况下都取得相同的属性值。尤其当属性为引用值时，会相互干扰。
5.组合构造函数和原型模式
将实例属性在构造函数中定义。
所有实例共享的属性和方法在原型中定义。

	function Person(name,age){
			this.name = name;
			this.age = age;
		}


		Person.prototype = {
			constructor: Person,
			sayName: function(){
				alert(this.name);
			}
		};
		var wang = new Person("jack",10);
		wang.sayName();
		var li = new Person("nike", 10);
		li.sayName();

说完了对象的创建，再说一下 对象的继承。
1.原型链继承
每一个构造函数中都有一个指针prototype，这个指针指向原型对象，而原型对象中又都有一个属性constructor，指向这个构造函数。同时每个实例中都有一个指向原型对象的指针。

		function SuperType(){


		}
		SuperType.prototype.getSuperValue = function(){


		};
		function subType(){


		}
		subType.prototype = new SuperType();//重写了subType的原型,此时constructor指向superType的原型对象
		subType.prototype.getSubValue = function(){


		};

注意：新加的子类原型方法，应该在继承了父亲原型之后。
           使用原型链方法继承时，不能用对象字面量来创建原型方法，这样会重写子类原型，使得constructor指向Object。
问题：a.由于包含引用型的原型属性会被所有实例共享。
               所以，如果父类的构造函数中有一个引用型数组，则对父类的每一个实例间无影响。
               但是子类的原型是父类的一个实例。
               子类的所有实例都会共享这个属性。
            b.创建子类实例时无法向父类的构造函数传参。
2.借用构造函数 

		function superType(name){
			this.name = name;
			this.colors = ["black","green"];
		}
		function subType(){
			superType.call(this,"jack");
			this.age = 10;
		}

在调用subType()时，会借调superType()的所有代码，子类的实例创建实例自己的colors副本。
问题：方法都在构造函数中定义，没有了函数的复用。
           同时，在父类原型中定义的方法和属性，子类无法继承到。
3.组合继承
通过原型链来实现对原型属性和方法的继承；借用构造函数来实现对实例属性的继承。
问题：无论在什么情况下，都会调用 2次父类构造函数。

	function superType(name){
			this.name = name;
		}
		superType.prototype.getSuperValue = function(){


		};
		function subType(name,age){
			superType.call(this,name);
			this.age = age;
		}
		subType.prototype = new superType();
		subType.prototype.constructor = subType;
		subType.prototype.sayAge = function(){


		}

4.原型式继承
基于现有的对象，再创建一个新对象。
适用场景：只想让一个对象与另一个对象保持相似的情况下。

		function object(o){
			function F(){} //创建临时性的构造函数
			F.prototype = o;//将传入的对象作为这个构造函数的原型
			return new F();//返回这个临时类型的新实例
		}

object()对传入的对象进行了浅复制。

person1 = object(Person);

person2 = object(Person);

相当于创建了2个person的副本。

5.寄生式继承
与创建对象的工厂模式类似

	function another(o){
			var clone = object(o);
			clone.sayHi = function(){


			};
			return clone;
		}

问题：无法做到函数的复用。
6.寄生组合式
这是最有效的一种继承方式。只 调用了一次superType()构造函数，同时还没有改变原型链。
首先创建如下函数：

		function ip(subType,superType){
			var prototype = object(superType.prototype);
			prototype.constructor = subType;
			subType.prototype = prototype;
		}

然后使用时，与组合继承类似，但是不同的是将subType.prototype = new superType();subType.prototype.constructor = subType;这两句代码换成，ip(subType,superType);


最后，理解对象的创建和继承，关键是理解构造函数，原型对象以及实例之间的关系。这个稍后上图。