传统的Web开发模式中，JavaScript一直被当作过程化的语言使用，比如表单验证之类。其实，JavaScript提供了完善的机制来实现面向对象的开发思想，这在Ajax技术上，表现得淋漓尽致。
总结下JavaScript面向对象的基础：（结合了《Web 2.0 开发技术详解》这本书，希望对大家有帮助）
1 定义类
用定义函数的方式（即用“function”关键字定义）：
function class01 () { //……. }
此处class01是一个函数，也是一个类。作为函数，可以理解为类的构造函数（初始化）。在JavaScript中，函数和类就是一个概念。
BTW：函数声明的方法：
（1）function fun1(…) {…}
（2）var fun1 = function(…) {…}; // 注意无名函数在调用之前，必需先定义
（3）var fun1 = function fun2(…) {…};
（4）var fun1 = new Function(p1, p2, …, pN, body);
2 定义对象
1）使用new操作符。– 适用内部类 （如Date类，Array类，String类，RegExp，Math，Error，Object）和用户自定义类。
如：
function class01() { // 类成员的定义 }
var obj = new class01(); // 即所有函数都可以用new来操作。
e.g:
var obj = new Object();
obj.name = "ljlwill"; // 定义name属性
obj.hello = function(…) {….} // 定义obj的hello方法
有个小技巧，以下大家发现没有
var namespace = new Object();
var namespace.class1 = function() {…..}
var obj1 = new namespace.class1();
>> 对象名起到一个命名空间的作用。先用new出一个namespace对象，把namespace对象的方法定义为类的形式，再new出一个新的obj1
2）使用｛｝大括号创建无类型对象
传统的面向对象语言中，每个对象都会对应到一个类，而JavaScript中的对象，其实就是属性（方法）的一个集合，无严格意义的类的概念。故可用｛｝的语法创建一个对象。
如：
var user = { name: "ljwill", // 定义了name属性，初始化为“ljlwill
hobby: ['basketball', 'football', 'ping-pong'], // 定义了爱好，类型为数组
// 定义hello方法
hello: function() { alert("Hello, " + this.name); },
…… }
可看到形式，其中属性名和其定义之间用：（冒号）隔开，以，（逗号）结尾。很是紧凑，清晰，减少代码体积。
3 对象的属性和方法的引用
1） 对象名.属性名（方法名） — 即用.符号引用
2） 对象名["属性（方法）名"] — 即用[]符号引用
如：
var arr = new Array(); // 为数组添加一个元素a
arr["push"]("a"); arr.push("a");
// 计算数组长度
var len = arr["length"];
var len = arr.length;
用方括号[]的引用对象属性（方法），类似于数组，体现了一个JavaScript对象就是一组属性（方法）的集合这个性质。适用于不确定具体要引用哪个属性（方法）的场合。 在document的集合对象中，也有类似[]的用法，如果引用某一个“myForm"的表单对象：document.forms["myForm"]，当然，也可以写成document.forms.myForm。（注意，这里的forms对象是一个内部对象）
4 对象的属性和方法的操作
如何为一个对象添加，修改或删除其属性和方法呢？
在一些语言中，要修改一个已生成的对象的属性或方法，必须在对应的类修改，重新实例化，再重新编译。JavaScript却可以灵活的动态添加，修改或删除其属性和方法。
如：先创建一个空对象user：var user = new Object();
1）添加属性。
user.name = "jinlie"; // 为其添加name属性
user.age = 25; // 为其添加age属性
user["name"] = "jinle" // 使用[]
user["age"] = "25"
// 可否发现[]方式有个而外特点, 可以使用非标识符字符串作为属性名称，如数字开头或出现，user["007 name"] = "jinlie"，如果user.007 name就错误了。
// 这一属性可以很容易实现一个简单的哈希表。在此不详述。 输出试试：alert(user.name);
2）添加方法
user.getName = function() {
// 可添加参数 return this.name;
} // alert(user.getName());
3）修改属性
即用新的属性替换旧的属性
user.name = "hello"; // 测试：alert(user.getName());
4）删除属性和方法
将其置为undefined即可。
user.name = undefined;
user.getName = undefined;
到此，我们可以感受JavaScript的强大的灵活性。
5 prototype原型对象
在JavaScript中，每个函数（function）其实也是一个对象，他们对应的类是“Function”，而每个函数对象都具有一个子对象 prototype。所以，prototype表示了该函数的原型，也即是表示一个类的成员的集合。 prototype是一个对象，也可以对其方法进行动态修改：
如：
function class01 { // ….. }
// 对类的prototype对象增加方法
hello class01.prototype.method = function() { alert("Hello Word!"); }
var obj = new class01();
obj.hello(); // 调用hello()方法
看个有趣的例子：
// 为所有的Function函数对象添加method1方法
Function.prototype.method1 = function() {
alert("This is a function.");
}
function func1() { alert("this is func1"); }
func1.method1(); // 执行了alert("This is a function")
func1.method1.method1(); // 执行了alert("This is a function")
func1.method1.method1()是个递归定义，因为method1本身也是一个函数，便具有了函数对象的属性和方法，所以它调用了method1这个函数对象的method1方法。结论：所有对Function类型的方法扩充都具有这样的递归性质。
6 类成员的访问机制
1）公有成员，私有成员
在JavaScript中，并没有特殊的机制（比如用像一些语言中有关键字private，public等）来访问其成员，但可以通过变量的作用域性质来实现这些功能。– 在一函数内部定义的变量称为局部变量，它不可以被函数外边的程序所使用，却可以被其内部定义的嵌套函数所使用。
有思路了吧？如：
function class1() {
var name = 'ljlwill'; // 私有属性
// 私有方法
function privateMethod(…) {
….
}
// 公有方法
this.pubMethod = function(…) {
….
}
}
// 建以对象obj
var obj = new class1();
obj.pubMethod();
注意，prototype定义的类成员却不可以访问其构造体中定义的局部变量（私有成员） 。
2）静态成员
它可以通过“class.staticMemberName（类名.静态成员名）”访问。
实现：
function class1() {
….
}
calss1.staticName = "ljlwil";
class1.staticMethod = function(…) { …. }
如果想给所有的对象添加静态成员（比如静态方法）：
Function.prototype.staticMethod = function(…) { … }
7 类的继承
继承是OOP中很重要的IDEA。很抱歉，JavaScript没有专门的机制（extends）来实现，但还是可以使用以下方式实现继续
1）拷贝一个类的prototype到另外一个类来实现继承。
如：
function class1() {
…
}
function class2() {
..
}
class2.prototype = class1.prototype; // 这样class2有了其公有类成员的属性或方法
下边的语句是成立的：
var obj = new class2();
obj instanceof class1; // intanceof 操作符判断一个对象是否是某一类的实例。
obj instanceof class2;
注意：在JavaScript中，除了基本数据类型（数字，字符串，布尔等），所有的赋值或函数传参都是引用传递，所以class2的prototype引用了class2的prototype，如果改变class2的prototype，class2的prototype也随之改变。所以，注意要不允许类成员的重新定义，用prototype实现继承，还是蛮好用的。
2）使用发射机制实现正确继承
发射机制指的是程序在运行时能够获取自身的信息。
如：
// 为Object类添加静态方法extend
Object.extend = function(destination, source) {
for(p in source) {
destination[p] = source[p];
}
return destination;
}
// 通过Object类为所有对象添加extend方法
Object.prototype.extend = function(object) {
return Object.extend.apply(this, [this, object]);
}
// 定义class1
function class1() {…)
class1.prototype = {
method1: function(…) {…},
method2: function(…) {….}
}
// 定义class2
function class2() {….}
// 继承
class2.prototype = (new class1()).extend({ // 不要把new class1()换成class1，这样和prototype实现继承一样的错误哦！
// 重新定义method1
method1: function() {
….
}
}
);
// 定义对象
var obj1 = new class1();
var obj2 = new class2();
// 试试吧
obj1.method1();
obj1.method2();
obj2.method1();
obj2.method2();
8 抽象类
JavaScript的抽象类也是没任何机制支持的。但却还是可以实现。
传统的面向对象语言中，抽象类的概念是，具有虚函数的类。而虚函数指的是，只做了一个声明而未实现的方法。在JavaScript中，虚函数可以看作该类中没有定义的方法，但已经通过this指针使用了（在其他语言中，虚函数必须先声明）。
如：
Object.extend = function(destination, source) {
for(p in source) {
destination[p] = source[p];
}
return destination;
}
// 定义一个抽象基类base，无构造函数
base.prototype = {
initialize: function() {
this.oninit(); // 调用了一个虚方法
}
// 如果要在基类中添加虚方法的一个定义，也可以的：
// oninit: function() {} // 虚方法是一个空方法，由派生类实现
}
function class1() {….}
class1.prototype = (new base()).extend({
// 实现抽象类中的oninit虚方法
oninit: function() {
// 实现
}
});
好，今天就谈到这，JavaScript一个非常灵活的设计语言。学好基础，看看那些类的设计模式，和一些出名的框架，不禁要
