目录：
- constructor & prototype
- 为构造函数添加属性和方法的多种不同方法
- 组合使用this和prototype关键字创建构造函数（常用方法）
- 用对象直接量作为构造函数的参数
- 方法的链式调用
- 继承：JavaScript中通过对象的原型链实现原型继承
- 多态：将某个方法替换为一个同名的功能类似的方法，只是做了针对性的改变。只需要重写一个函数并给它和原方法相同的方法即可
- JavaScript函数的apply和call方法
- JavaScript函数的apply和call方法(待完善)
- 公有、私有以及受保护的属性和方法
1.constructor & prototype
function Accom(){}; //创建一个构造函数
//创建两个对象
var house=new Accom();
var apartment=new Accom();
通过构造函数创建的对象有一个属性constructor,这个属性指向创建该对象时所用的Javascript构造函数。
house.constructor===Accom; 或者 house instanceof Accom; //true
JavaScript中的每个构造函数都有一个prototype的属性，这个属性指向一个对象。当用关键字new来创建一个对象实例时，实例中所包含的属性和方法都来自prototype所指向的这个对象
2.为构造函数添加属性和方法的多种不同方法
function Accom(){};
Accom.prototype={
share: false,
unlock: function(){}
}; //通过对象直接量为构造函数添加属性和方法
Accom.prototype.rooms=5; //通过protype关键字添加属性
Accom.prototype.lock=function(){}; //通过protype关键字添加方法
在所有嵌套函数中都可以访问定义在其父函数中的变量
3.组合使用this和prototype关键字创建构造函数（常用方法）
一般用this关键字来初始化那些希望在对象创建时进行初始化的属性，而用prototype设置其他属性以及对象的方法。每次通过构造器创建一个新的对象实例，构造函数都会被执行一次，而通过prototype关键字来定义只需要定义一次。
function Accom(floors,rooms){
this.floors=floors||0; //设置默认值0
this.rooms=rooms||7; //设置默认值7
}
Accom.prototype.isLocked=false;
Accom.prototype.lock=function(){
this.isLock=true;
};
var house=new Accom(2,5); //实例化类
4.用对象直接量作为构造函数的参数
当类的规模越来越大时给对象实例的属性设置初始值比较麻烦，可以用对象直接量
function Accom(defaults){
defaults=defaults||{} //如果没有传入值默认为空的对象直接量
//如果defaults对象含有某个属性，就将实例对象中同名属性的值设为defaults提供的值，否则设为默认值
this.floors=defaults.floors||0;
this.rooms=defaults.rooms||0;
}
Accom.prototype.isLock=false;
Accom.prototype.lock=function(){
this.isLock=true;
}
//实例化一个对象
var house=new Accom({
floors:2,
rooms:7
});
5.方法的链式调用
只需要在“类”中的每个方法最后通过this关键字返回对象实例的引用就可以实现链式调用
function Accom(){}
Accom.prototype.lock=function(){
this.isLocked=false;
return this; //通过返回上下文返回的是调用这个函数的对象，这个对象包含所有的方法，因此可以在本方法后调用其他方法
}；
Accom.prototype.alarm=function(){
alert("Sounding alarm!");
return this;
};
var house=new Accom();
house.lock().alarm(); //实现链式调用
6.继承：JavaScript中通过对象的原型链实现原型继承
function Accom(){
this.isLocked=false;
this.isAlarmed=false;
} //父类
Accom.prototype.lock=function(){
this.islocked=true;
};
Accom.prototype.unlock=function(){};
function House(defaults){
defaults=defaults||{};
this.floors=2;
this.rooms=defaults.rooms||7;
}
//将House类的原型设为Accom类的一个实例，这个实例包含其所有属性和方法，然后传递给House类的原型
House.prototype=new Accom();
House.prototype.constructor=House; //上一步传递给House过程constructor的值也被复制，需要重设constructor使其指向新的子类
var myHouse=new House;
myHouse.lock(); //继承了Accom的方法
alert(myHouse instanceof Accom); //true,因为House继承自Accom
7.多态：将某个方法替换为一个同名的功能类似的方法，只是做了针对性的改变。只需要重写一个函数并给它和原方法相同的方法即可。
//上面的例子中，针对House类重定义lock方法，即多态
House.prototype.lock=function(){
//通过call方法将上下文传递给父类Accom的lock方法，从而确保lock方法中任何对this的引用都指向当前这个House的对象实例
Accom.prototype.lock.call(this);
alert(this.isLocked); //true,说明调用正确
}
8.JavaScript函数的apply和call方法。call和apply区别在于，使用apply时，所有参数都放在一个单独数组中，而call中参数依次列出用逗号隔开。
function Accom(){
this.isAlarmed=false;
} //定义一个类
var Alarm={
arm: function(message){
this.isAlarmed=true;
alert(message);
}
}; //创建一个对象，其方法可以被代码中其他对象所使用
var myHouse=new Accom();
Alarm.arm.call(myHouse,"Alarm activated"); //通过call将对象实例myHouse上下文传入arm函数
alert(myHouse.isAlarmed); //true,改变了
9.arguments对象 依次包含了传入函数的各个参数的一个数组,该数组不具备标准数组的其他方法（例如排序）
使用函数apply方法时，arguments就可以体现其价值，因为apply方法将所有参数放入一个数组内进行传递。
10.公有、私有以及受保护的属性和方法
var Accom=(function(){
function Accom(){};
//此处定义为私有变量
var _isLocked=false,_alarmMessage="Alarm activated!";
//在当前作用域上定义的函数（而未在构造函数原型删定义）为“私有的”
function _alarm(){
_isLocked=true;
alert(_alarmMessage);
}
//所有在原型上定义的方法为公有的,此处可以访问私有方法和变量
Accom.prototype.lock=function(){
_isLocked=false;
_alarm();
};
//定义一个函数对私有变量进行只读访问
Accom.prototype.getIsLocked=function(){
return _isLocked;
};
//定义一个函数对私有变量进行只写访问
Accom.prototype.setAlarmMessage=function(message){
_alarmMessage=message;
};
//返回这个作用域中的类，使之在外层作用域中可用
return Accom;
}());
var house=new Accom();
house.lock(); //弹出警告消息 “Alarm activated”
house.alarm(); //错误！_alarm函数从未被公开