抛出异常与try catch

Question

两个都可用，有什么细节需要注意的吗？或者用什么都可以？

Answer 1

使用方式：try{
    ....
}catch(Exception1 e1){
}catch(Exception2 e2){
}
...Exception1不能包括Exception2

Answer 2

转来的，楼主看看就什么都明白了在JavaScript可以使用try...catch来进行异常处理。例如： try {
foo.bar();
} catch (e) {
alert(e.name + ": " + e.message);
}目前我们可能得到的系统异常主要包含以下6种: 
EvalError: raised when an error occurs executing code in eval() 
RangeError: raised when a numeric variable or parameter is outside of its valid range 
ReferenceError: raised when de-referencing an invalid reference 
SyntaxError: raised when a syntax error occurs while parsing code in eval() 
TypeError: raised when a variable or parameter is not a valid type 
URIError: raised when encodeURI() or decodeURI() are passed invalid parameters 
上面的六种异常对象都继承自Error对象。他们都支持以下两种构造方法: 
new Error();
new Error("异常信息");手工抛出异常的方法如下：try {
throw new Error("Whoops!");
} catch (e) {
alert(e.name + ": " + e.message);
}如要判断异常信息的类型，可在catch中进行判断：try {
foo.bar();
} catch (e) {
if (e instanceof EvalError) {
alert(e.name + ":" + e.message);
} 
else if (e instanceof RangeError) {
alert(e.name + ": " + e.message);
} 
// etc 
}Error具有下面一些主要属性： 
description: 错误描述 (仅IE可用). 
fileName: 出错的文件名 (仅Mozilla可用). 
lineNumber: 出错的行数 (仅Mozilla可用). 
message: 错误信息 (在IE下同description) 
name: 错误类型. 
number: 错误代码 (仅IE可用). 
stack: 像Java中的Stack Trace一样的错误堆栈信息 (仅Mozilla可用). 
因此为了更好的了解错误信息我们可以将catch部分改为如下形式： try {
foo.bar();
} catch (e) {
if (browserType != BROWSER_IE) {                            
alert("name: " + e.name + 
"message: " + e.message + 
"lineNumber: " + e.lineNumber + 
"fileName: " + e.fileName + 
"stack: " + e.stack);        
} 
else {                    
alert("name: " + e.name +     
"errorNumber: " + (e.number & 0xFFFF ) + 
"message: " + e.message");        
} 
}JavaScript中的throw命令事实上可以抛出任何对象，并且我们可以在catch接受到此对象。例如：try {
throw new Date(); // 抛出当前时间对象 
} catch (e) {
alert(e.toLocaleString()); // 使用本地格式显示当前时间 
}

Answer 3

理论上说try……catch与throws都是可以的
当没有设计分层的时候随便
涉及分层就建议把异常一直往上throws，真正到最上层了再处理（比如在Action中再处理）

Answer 4

1、异常分两大类，一类是继承自 RuntimeException 的异常，另一类是继承自 Exception 的异常
Exception 是必须捕捉的异常，因为这类异常代表程序不可预料的错误，比如程序正在与另一台计算机通过网络进行信息交换时，网线被人剪断，这类异常必须处理
RuntimeException 是可以完全避免的错误，比如空指针异常，只要我们在使用一个引用前先判断一下变量是否为空就可以避免出现，这类异常不必捕捉2、异常处理的方法一般有两种，或者自己捕捉，然后自己处理，或者抛给你的方法的调用者
例如在创建一个 Socket 时，可能会产生 SocketException，则可以这样处理：public void aMethod(){
    try{
        // 自己捕捉异常，自己处理
        Socket socket = new Socket();
        // 其它代码
    }catch(SocketException sEx){
       // 处理异常的代码
   }
}
或者// 把出现异常的情况告诉方法的调用者，让调用者捕捉或处理异常
public void aMethod() throws SocketException{
    Socket socket = new Socket();
}3、当一段代码可能出现多个异常时，可以分别捕捉，    try{
        Socket socket = new Socket();
        // 其它代码
    }catch(Exception1 ex){
       // 处理Exception1的代码
    }catch(Exception2 ex){
       // 处理Exception2的代码
    }
但是在这种情况下，Exception2 不能是 Exception1 的子类，否则会报编译错误，因为 Exception2 语句块内的代码不可能被执行到。
4、在异常捕捉语句块中，当语句块中间发生了异常时，被捕捉的语句块中剩下的语句将不会被执行，因此在 try..catch 中，最好把释放资源的语句(比如关闭文件操作)写到 finally 块中，比如InputStream is1 = null;
InputStream is2 = null;
try{
    is1 = new FileInputStream("C:\\a.txt");
    is2 = new FileInputStream("C:\\b.txt");
    
    // .....    // 如果文件a.txt成功打开，而文件b.txt打开失败，则 try 内部的 is1.close(); 和 is2.close(); 将不会被执行
    is1.close();
    is2.close();
}catch(IOException ioEx){
    // 异常处理代码
}finally{
    // 关闭 is1 和 is2 的操作应该放在这里
    if(is1 != null){
        try{
            is1.close();
        }catch(Exception ex){}
    }
    if(is2 != null){
        try{
            is2.close();
        }catch(Exception ex){}
    }
}5、如果一个方法中声明了抛出异常 ExceptionA，而在子类中重写了这个方法，那么子类重写的这个方法能够声明抛出的异常是有限制的：或者声明抛出 ExceptionA、或者声明抛出 ExceptionA 的子类，或者不声明抛出异常。
简单点说，如果子类重写父类的方法时，子类重写的方法声明抛出的异常应该比其父类方法声明抛出的异常更精确。比如// 父异常
class SuperException extends Exception{
    //......
}// 子异常
class SubException Extends SuperException {
    //......
}class Human {
    public void method() throws SuperException {
        // ......
    }
}
// 下面重写了父类的 method 方法，前两种写法会报编译错误
class Woman extends Human {
    // compile failed
    @Overrided
    public void method() throws Exception {
        // ......
    }
    
    // compile failed
    @Overrided
    public void method() throws IOException {
    }    // compile OK
    @Overrided
    public void method() throws SuperException {
    }
    
    // compile OK
    @Overrided
    public void method() throws SubException {
    }    // compile OK
    @Overrided
    public void method(){
    }
}
这个规则可能比较怪，其实仔细想想也都是很有道理的。比如上面的 Woman.method() 如果声明抛出IOException，则在下面的代码中将会产生矛盾：
public void testMethod(){
    Human object = new Woman();
    .
    .
    .
    .
    .
    object.method();
}
由于 object 是 Human 类型，所以在调用 object.method() 时应该捕捉SuperException 就可以了。而 object 在运行时却是 Woman 类型的，它在运行时可能会抛出 IOException，这样这个非 RuntimeException 就没有被捕捉到了，从而违背了 java 的安全规则。

Answer 5

两个都是可以用的，一个是thorws，另外的是 try catch。
   不过更加推荐使用try catch的方法，因为这样一旦你的程序出现了异常，可以跟踪异常。try{}catch(Exception e){
 e.printStackTrace();//能跟踪异常。
}