1）首先，不要丢弃异常，即catch异常后什么也不做。如果你认为不能很好的处理该异常，就让它继续传播，让别的地方处理去；或者，你可以把一个低级的异常转换成应用级的异常，重新抛出。

2）catch语句应该指定具体的异常类型。不要把不该捕获的异常也扣下了。

3）在finally里面释放资源。如果finally里面也会抛出异常，也一样的需要try catch处理。

4）不要把大量的代码塞在try catch块里面，分离各个可能出现异常的语句并分别捕获异常。

5）由于异常可能导致输出的数据不完整，你应该作出相应处理，至少要有提示数据的不完整。

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

1)对象冒充
2)call方式
3)apply方式
4)原型链
5)混合方式

1)对象冒充

function People(name, age) {
	this.name = name;
	this.age = age;
	this.speak = function() {};
};

function Chinese(name) {
	this.inherit = People;	//冒充，会继承所有方法
	this.inherit(name, age);	//继承，必须指定继承的属性
	delete this.inherit;	//删除继承

	//需要定义的新方法、属性或者“重载”的方法在删除inherit后
	this.speak = function() {};	
}

2)call方式
封装了方式1的“经典三句”，一样的效果。

function Sub(param1, param2) {
	Super1.call(this, param1);
	Super2.call(this, param2);
};

3)apply方式
同call一样，只是使用方式不同：Super.apply(对象，参数数组);

function Sub(param1, param2, param3) {
	Super1.apply(this, new Array(param1, param2);	
	Super2.apply(this, new Array(param3);
};

4)原型链方式
父类不用构造函数创建，而是原型方式
缺点：不能传递参数，不支持多重继承

function Super() {};
Super.prototype.param1 = "sth.";
Super.prototype.foo = function() {};

function Sub() {};
Sub.prototype = new Super();

usage: var aSub = new Sub; Sub.foo();

5)混合方式：
a)用构造函数定义新的属性，用call或apply继承属性。
b)用原型方式定义新的方法，用原型链继承方法。

function Super(param1) {
	this.param1 = param1;
	Super.prototype.foo = function() {};
};

function Sub(param1, param2) {
	Super.call(this, param1);
	this.param2 = param2;	//别用this.prototype.param2 = param2;

	Sub.prototype = new Super();
	Sub.prototype.bar = function() {};
};

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

1) 工厂方式
2) 构造函数方式
3) 原型方式
4) 混合的构造函数/原型方式
5) 动态原型方式

1) 工厂方式
     a)先创建对象，再添加属性和方法。
     b)总是为每个对象创建独立的函数版本。
     c)不利于封装和复用。

eg1)
     var sb = new Object;
     sb.name = "James";
     sb.speak = function() {};

eg2)
function People() {
     var sb = new Object;
     sb.name = "James";
     sb.speak = function() {};

     return sb;
}

usage: var james = People; var james2 = People;

eg3)
function People(name) {
     var sb = new Object;
     sb.name = name;
     sb.speak = function() {};

     return sb;
}

usage: var james = People("James"); var jodan = People("Jodan");

2) 构造函数方式
a)不在函数内部创建对象，而是通过this关键字指向当前对象。
b)为每个对象创建独立的函数版本，因此会重复生成函数。

eg1)
function People(name, age) {
     this.name = name;
     this.age = age;
     this.speak = function() {};
}

usage: var james = new People(james, 30);

3) 原型方式
a)所有的属性和方法都是通过Prototype添加，不能通过构造函数传递参数初始化属性。

eg1)
function People() {};
People.prototype.name = "James";
People.prototype.speak = function() {};

usage: var james = new People();

4) 混合的构造函数/原型方式。
a)对象属性，用构造函数方式。
b)对象方法，用原型方式。

eg1)
function People(name) {
     this.name = name;
};

People.prototype.speak = function() {};

eg2) //把原型写入类内部，可能更符合习惯
function People(name) {
     this.name = name;
     People.prototype.speak = function() {};
};

5) 动态原型方式
a)创建对象的方法后，下一次使用不再重复创建。

eg1)
function People(name) {
     this.name = name;

     if(typeof People._initialized = "undefined") {
         People.prototype.speak = function() {};
          People._initialized = true;
     };
}

总结：
实际应用中，用混合的构造函数/原型方法或者动态原型方式去构造JS对象。
但熟悉各种对象构建方式，有利于对java script对象实现机制的理解。

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱