前言
今天，WEB2.0时代的到来，给了JavaScript又一次大展身手的机会。Web2.0借助JavaScript技术，使得客户端的Web体验更加丰富多彩，同时JavaScript面对的问题域也变得错综复杂起来，JavaScript代码也随着Web页面的多样化和功能的丰富而快速膨胀。以前的过程式的JavaScript开发方法已经不能适应Web2.0的开发需求，需要一种更先进的设计方法来指导JavaScript的开发，这就是这里我们要讨论的面向对象。
面向对象概念的提出，是软件开发工程发展的一次革命，有了面向对象，很多复杂的大型应用程序的开发可以简化。可以说，有了面向对象，我们手里才得到了一把真正的利刃，可以得心应手的处理复杂而又规模庞大的问题域。
面向对象的三个基本特征是：
- 封装-把自己的数据和方法封装在对象内部，并让私有的数据和方法在对象外部不可见，而共有的数据和方法在对象外部可见。
- 继承-在无需重新修改原来对象的前提下，让另一个对象获得原对象的属性和方法的能力
- 多态-子类可以定义与父类具有相同signature的方法。
因此我们就这三个基本特征展开JavaScript面向对象的讨论。
基本概念
JavaScript语言对对象提供了天然支持。数组（Array）是对象，函数（function）是对象。但是JavaScript不是一种真正意义上的面向对象语言。这是因为JavaScript并不具备完整的面向对象三个基本特征。
在正式开始讨论之前，首先要对JavaScript的类，成员变量，成员函数，类变量，类方法这几个概念进行说明。
Ÿ 类
JavaScript中并没有类的概念，也就是说，JavaScript中并没有语法支持“类”。因此，JavaScript中的类其实都是使用function来模拟的。
类的定义：
function Circle(r){
this.r = r;
}
类的实例化：var circle = new Circle(3);
Ÿ 成员变量
成员变量可以通过多种方式定义：
构造器中： this.r = r;
对象：circle.name="my circle";
Ÿ 成员函数
成员函数也可以通过多种方式定义：
构造器中：
function Circle(r){
this.r = r;
function sqr(){
return r*r;
}
}
prototype：
Circle.prototype.getName=function(){
return this.name;
}
Ÿ 类变量
类变量是属于类的变量。就像java里用static声明的变量，可以直接用类就可以访问。由于类变量是属于类的，因此所有这个类的实例也可以访问这个变量。因此，任何实例都不应该修改类变量（JavaScript中没有类似java的final关键字使类变量不可变）。类变量与通过prototype定义的变量的功能类似，但是他们的访问方式不同。
访问prototype变量：Circle.prototype.PI=3.14;
访问类变量：Circle.PI=3.14;
//使用prototype里的变量
Circle.prototype.area1 = function(){
return this.PI*this.r*this.r;
}
//使用类变量
Circle.prototype.area2 = function(){
return Circle.PI*this.r*this.r;
}
Ÿ 类方法
类方法是直接在类上定义的方法。注意，在类方法中不能使用this关键字，就像是在java的static方法中，不能使用this一样。
Circle.max = function(a,b){
return a.r>b.r?a:b;
}
var maxCircle = Circle.max(new Circle(1),new Circle(2));
面向对象的三个基本特性
在有了上面的知识以后，下面就开始依据面向对象三个基本特征，对JavaScript的面向对象特性进行讨论。
1. 封装
JavaScript中，所有元素都可以认为是对象。这就是JavaScript对对象的天然支持。在JavaScript的对象里，还可以定义方法（function），数据变量（var）。这样，JavaScript对象可以把数据和方法封装在对象内部。
JavaScript是如何实现对象数据的访问控制的呢？JavaScript跟别的面向对象语言一样，也是通过function和变量的不同的声明方式而实现访问控制的。
Ÿ 公有成员
对象的成员都是公有成员，任何函数都可以访问，修改或删除这些成员。有两种主要途径给对象添加公有成员：
Ø 构造器：
构造器中，使用this变量来向对象添加成员。注意，这里只是用this变量添加了属性成员。用this变量添加的function成员，而特权成员(见下文解释)而不是公有成员。
function Container(param){
this.member = param;
}
Ø 原型：
使用prototype添加成员是很常用的一种给对象添加公共成员的方式：
Container.prototype.stamp = function(string){
return this.member+string;
}
Ÿ 私有成员
私有成员要由构造器生成。构造器的参数，以及其中通过var声明成员都是私有成员。私有成员是无法被公有成员访问的。但是公有成员可以通过一些技巧来访问私有成员。例如，
function Container(param){
function dec(){
if(secret>0){
secret-=1;
return true;
}else{
return false;
}
}
this.member = param;
var secret = 3;
var self = this;
}
在上面的代码例子中，有三个私有成员：param,secret,self。它们在对象内部，并且在对象外部不能访问这三个成员，同时也不能被对象的公有方法访问。他们只对私有成员可见。
这里有一个技巧，就是定义了一个私有的self变量。通过这个self变量，可以在让私有成员中访问公有成员。
Ÿ 特权成员
特权成员实际上是特指function成员。特权成员可以访问私有成员（变量和方法），同时它对公共域也是可见的。可以删除或替换一个特权成员，但是不能对他进行修改。
特权方法是用this在构造器中定义的。
function Container(param){
function dec(){
if(secret>0){
secret-=1;
return true;
}else{
return false;
}
}
this.member = param;
var secret = 3;
var self = this;
//特权成员
this.service = function(){
if(dec()){
return self.member;
}else{
return null;
}
};
}
上面的代码片段中，service方法就是一个特权成员。可以看到，在service方法中，调用了私有方法dec(),而dec又访问了私有变量secret.
2. 继承
JavaScript继承问题一直是网上被讨论最热烈的一个JavaScript问题。在详细讨论JavaScript的继承之前，我们先看一下“继承”的概念。
继承，让子类具备父类的特性。继承，描述的是类型层面上而不是个体层面上的特性。因此，继承，只应该是描述类型的，也就是说，只能是类之间存在继承关系，而对象实体之间是不存在继承关系的。
由于JavaScript并不是很清晰（类跟对象没有明显的区分），因此导致JavaScript中的继承实现要大费周折。很多人为JavaScript想出了各种各样的实现继承的方法，包括：构造器继承法，原型继承法，实例继承法，附加继承法。
这里不去详细讨论每一种继承的实现思路。
在《JavaScript权威指南1.5》中列出的是prototype继承。
function SubCircle(x, y, r) {
this.x = x;
this.y = y;
this.r =r;
}
SubCircle.prototype = new Circle(0);
这种继承方式，会有一点问题，就是原来在SubCircle的prototype中定义的方法和属性丢失。
在prototype1.5 framework中，通过属性复制定义另一中继承方式。核心概念就是把Circle的prototype中的所有成员复制到SubCircle中，这样可以确保SubCircle的prototype中的成员不会丢失，但是这样也有个问题，就是Circle中定义的公有成员，特权成员并没有被继承到SubCircle中。
为了解决这个问题，可以综合上面两种继承的有点，进行如下的实现：
3. 多态
首先看一下例子：
///////////define: Cricle//////////////////
function Circle(r) {
this.r = r;
}
Circle.PI = 3.14;
Circle.prototype.PI = 3.14;
Circle.prototype.area = function() { return Circle.PI*this.r*this.r; }
Circle.prototype.area2 = function() { return this.PI*this.r*this.r; }
//// test
c = new Circle(3);
//alert("area1 :"+c.area());
//alert("area2 :"+c.area2());
Circle.max = function(a, b) { return a.r>b.r ? a.r : b.r; }
//alert("max is "+Circle.max(new Circle(1), new Circle(3)));
c1 = new Circle(1);
c2 = new Circle(1);
c2.PI = 100;//Circle.prototype.PI=100;
//alert("c1.area1 "+c1.area());
//alert("c1.area2 "+c1.area2());
//alert("c2.area1 "+c2.area());
//alert("c2.area2 "+c2.area2());
////////////////////////define: SubCircle //////////////////
function SubCircle(x, y, r) {
this.x = x;
this.y = y;
this.r = r;
}
SubCircle.prototype = new Circle(0);
SubCircle.prototype.PI = 100;
SubCircle.prototype.move2 = function(x, y) { this.x = x; this.y = y;}
SubCircle.prototype.area = function() { return this.PI*this.r*this.r*this.r; }
//// test
sc = new SubCircle(0,0,2);
alert(sc.area());
调用sc.area()的执行顺序是：
sc.PI->sc.prototype.PI->100;
sc.area()->sc.prototype.area()->SubCircle(0,0,2).area()
从上面的调用顺序可以看到，SubCircle的调用过程中，只要属性和方法在子类中存在，就完全用子类的属性和方法。
如果要使用父类的属性和方法怎么办呢？这就要用到继承部分的支持。在继承的时候，子类的prototype中增加了一个属性superClass，这个superClass就是父对象的引用。因此就可以通过superClass调用父对象的属性和方法了。
命名空间
随着功能的增加，JavaScript代码也会变的越来越复杂，那么给JavaScript增加命名空间就显得尤为重要了。
JavaScript语言中没有对命名空间提供直接的支持，因此只有通过模拟实现命名空间。具体实现是使用闭包特性，使JavaScript代码位于某些特定的Function内。下面是命名空间的代码片段：
//最外层的包
var laputa = {};
//在laputa包内部定义了两个包：lang,util
laputa.lang={};
laputa.util = {};
//在lang包里定义了String类，
laputa.lang.String = {};
//String类的trim方法
laputa.lang.String.prototype.trim = function(){
return this.replace(/(^\s*)|(\s*$)/g, "");
};
//String类的toUpperCase方法
laputa.lang.String.prototype.toUpperCase = function(){
return this.toUpperCase();
}
//在util包定义了DocumentUtil类
laputa.util.DocumentUtil = {};
//DocumentUtil类的$方法
laputa.util.DocumentUtil.$ = function(id){
return document.getElementById(id);
}
//DocumentUtil类的$v方法
laputa.util.DocumentUtil.$v = function(id){
var el = laputa.util.DocumentUtil.$(id);
if(el){
return el.value;
}
return null;
}