第6章 面向对象的程序设计

定义
对象：无序属性的集合，其属性可以包含基本值、对象或者函数。

属性类型
包括数据属性和访问器属性
数据属性：
1.[[Configurable]] 表示能否delete属性
2.[[Enumerable]] 表示能否fon-in循环返回属性
3.[[Writable]] 表示能否修改属性的值
4.[[Value]] 包含这个属性的值

要修改属性默认的特性，必须使用ECMAScript的Object.defineProperty()

var person= {};
Object.defineProperty(person,"name",{
	configurable:false, //之后不能再改回true，否则报错
	writable:false,
	value:"Nicholas"
});
alert(person.name); //"Nicholas"
person.name="Greg" //严格模式会报错
delete person.name //严格模式会报错
alert(person.name); //"Nicholas"

访问器属性：
1.[[Configurable]] 表示能否delete属性
2.[[Enumerable]] 表示能否fon-in循环返回属性
3.[[Get]] 读取属性的值 非必须
4.[[Set]] 写入属性的值 非必须

var book= {
	_year:2004,
	edition:1
};
Object.defineProperty(book,"year",{
	get:function(){
		return this._year;
	},
	set:function(newValue){
		if(newValue>2004){
			this,_year=newValue
			this.edition += newValue-2004;
		}
	},
});
book.year=2005; 
alert(book.edtion); //2

定义多个属性：Object.defineProperties(o1,o2)
读取属性的特性：Object.getOwnPropertyDescriptor(o,property)

创建对象
1.工厂模式 用函数封装以特定接口创建对象的细节

function creatPerson(name,age,job){
	var o= new Object();
	o.name=name;
	o.age=age;
	o.job=job;
	o.sayName=function(){
		alert(this.name);
	}
	return o;
}
 var person=creatPerson("Greg",27,"Doctor");

2.构造函数模式 用函数封装以特定接口创建对象的细节

function Person(name,age,job){ //函数名大写
	this.name=name;  //作用域赋给新对象
	thisage=age;
	this.job=job;
	this.sayName=function(){
		alert(this.name);
	}
}
 var person=new Person("Greg",27,"Doctor");

2.原型模式 可以由特定类型的所有实例共享的属性和方法

function Person(){};
Person.prototype.name="aaa"
Person.prototype.age=29
Person.prototype.job="ccc"
Person.prototype.sayName=function(){
	alert(this.name);
}
var person1=new Person();
person1.sayName(); //aaa
var person2=new Person();
person2.sayName(); //aaa
alert(person1.sayName()==person2.sayName()) //true;

function Person(){};
Person.prototype={
//每创建一个函数都会自动创建prototyp对象，并且自动获得constructor属性
//以下为重写prototyp对象，所以constructor需要重新指向
//如果不加则Person.prototype.constructot不指向Person
	constructor:Person, 
	name="aaa",
	age:29,
	job:"ccc",
	sayName:function(){
		alert(this.name);
	}
}
//以上定义了以后constructor的enumrable会变成true，所以可以使用defineProperty
Object.defineProperty(Person.prototype,"constructor",{
	enumrable:false,
	value:Person
})

hasOwnProperty()访问实例属性，而非原型属性，可以用于区别。
in 操作符可以判断属性是否在对象中（不论是原型对象还是实例对象）
for-in 和 Object.keys()返回所有可枚举属性

原型对象里有引用类型值的属性时，会导致多个对象指向相同，一个改了其他也会改

组合使用构造函数模式和原型模式
集两种模式之长，定义2个实例，修改friends互不影响。

function Person(name,age,job){
	this.name=name;
	this.age=age;
	this.job=job;
	this,friends=["Shelly","Court"];
}
Person.prototype={
	constructor:Person,
	sayName:function(){
		alert(this.name);
	} 
}

动态原型模式
只会初始化一次方法,不会每次生成实例都创建一次sayName

function Person(name,age,job){
	this.name=name;
	this.age=age;
	this.job=job;
	if(type of sayName != "function"){
		Person.prototype.sayName=function(){
		alert(this.name);
		} 
	}
}

寄生构造函数模式

function Person(name,age,job){ //工厂模式函数名小写
	var o =new Object();
	o.name=name;
	o.age=age;
	o.job=job;
	o.sayName=function(){
		alert(this.name);
		};
	return o;
}
var friend=new Person("aaa",29,"java"); //工厂模式此处不使用new
friend.sayName(); //aaa
和工厂模式类似

稳妥构造函数模式
该模式不使用this,也不使用new调用构造函数。

function Person(name,age,job){
	var o =new Object();
	o.sayName=function(){
		alert(name);
		};
	return o;
}
var friend=Person("aaa",29,"java"); //此处不使用new
friend.sayName(); //aaa

继承
让原型对象指向另外一个类型的实例

寄生组合式继承
基本模式

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

案例

function SuperType(name){
	this,name=name;
	this,colors=["red","blue","green"];
}
SuperType.prototype.sayName=function(){
	alert(this.name);
}
function SubType(name,age){
	SuperType.call(this,name)
	this,age=age
}
inheritPrototype(SubType,SuperType);
SubType.prototype.sayAge=function(){
	alert(this.age);
}