1.1 JavaScript高级程序设计（第3版） 笔记---对象

    //[1]
		var person=new Object();
		person.name='yu';
		person.getName=function(){
			return this.name;
		};
		
		//[1,2]使用同一个接口创建很多对象，会产生大量的重复代码
		var person2={
 				name:"xi",
 				getName:function(){
 					return this.name;
 				}
 		}
		
		//[3]工厂模式:但却没有解决对象识别的问题
		function Person3(){
			var o=new Object();
			o.name="lin";
			return o;
		}
		
 		
 		//[4]构造函数  违背对象方法的封装原则
	 	function Person4(name){
			this.name=name;
			//，就是每个方法都要在每个实例上重新创建一遍
			/* this.getName=function(){
				return this.name;
			} */
			this.getName=getName;
	 	}
 		
	 	function getName(){
 			return this.name;
 		}
	 	
	 	var p4=new Person4("name");
	 	alert(p4 instanceof Person4);//true
	 	
	 	
	 	//[5]原型
 		/*
			1.Person.prototype 指向了原型对象，而Person.prototype.constructor 又指回了Person,实例中的指针仅指向原型，而不指向构造函数
			2.访问对象的属性或者方法，首先会在对象的域中查找，如果没有找到会到对象的原型中查找
			3.hasOwnProperty 对象自己的属性
			4.in 对象自己的属性+prototy
			5.for-in
			6.对原型对象所做的任何修改都能够立即从实例上反映出
			7.某个实例对原型中引用类型的修改，会反映在其他实例中 构造函数定义自己的属性，原型中定义函数和共享属性
		*/
	 	function Person5(age){
	 		this.age=age;//私有变量
	 	}
	 	Person5.prototype.name="prototype";//共享变量(java static)
	 	Person5.prototype.getName=function() {
	 		return this.name;
	 	}
	 	
	 	alert(Person5.prototype.isPrototypeOf(p5));//true
	 	
	 	var p5=new Person5(5);
	 	p5.name="override";
	 	alert(p5.name+" "+p5.age);//override 5
	 		 	
		var p52=new Person5(52);
		alert(p52.name+" "+p52.age);//prototype 52
		
		Person5.prototype.name="修改";
		alert(p52.name);//修改
		
		alert(p5.hasOwnProperty("name"));//true
		alert(p52.hasOwnProperty("name"));//false
	 	
		alert("name" in p5);//true;
		alert("name" in p52);//true;
		
		
		function Person6(){
			
		}
		Person6.prototype={
				constructor:Person6,//复制构造函数，其属性是可以枚举的了
				name:"prototype",
				getName:function() {
			 		return this.name;
			 	}
		}
		
 		function hasPrototypeProperty(object, name){
 			return !object.hasOwnProperty(name) && (name in object);
 		}
		
	
		//[7]继承  子类型的原型指向父元素的实例	 问题：父类中的引用属性将会被所有的子类共享
 		function SuperType(){
 			this.property ="super";
 			this.colors=["red","blue","green"];
 		}
 		SuperType.prototype.getSuperValue = function(){
 			return this.property;
 		};
 		SuperType.prototype.getSuperColors=function(){
 			return this.colors;
 		}
 		
 		function SubType(){
 			this.subproperty = false;
 		}
 		//实现继承
 		SubType.prototype=new SuperType();
		SubType.prototype.getSubValue = function (){
				return this.subproperty;
				};
				
		var instance=new SubType();
		alert(instance.getSuperValue());//super;
		var instance2=new SubType();
		var colors1=instance.getSuperColors();
		alert(colors1);
		colors1.push("yellow");//
		alert(instance2.getSuperColors());//red,blue,green,yellow
 		
		
		//[8]组合继承  子类构造函数与子类的原型
 		function SuperType2(name){
 			this.name=name;
 			this.colors = ["red", "blue", "green"];
 			this.getName=function(){
 				return this.name;
 			};
 		}
 		SuperType2.prototype.sayName=function(){
 			alert(this.name);
 		}
 		
 		
 		function SubType2(name){
 			//call(传递参数)与apply(传递数组)作用一样，改变context作用域
 			//不支持原型中定义的方法  //sub2.sayName();
 			SuperType2.call(this,name);
 		}
 		//继承原型的方法
 		SubType2.prototype=new SuperType2();
 		SubType2.prototype.constructor = SubType2;
 		
 		var sub2=new SubType2("构造函数");
 		alert(sub2.getName());
 		
 		var sub21=new SubType2("构造函数1");
 		sub2.colors.push("white");
 		alert(sub2.colors);//"red", "blue", "green","white"
 		alert(sub21.colors);//"red", "blue", "green"