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"