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"