1. try的意思，就是试着执行里面的语句，所以如果try内部抛出了异常 Exception，那么，将会执行catch 部分，以及try 外边的后面的语句。
2. 如果 try 内部出现了Error，表示出错，后面的语句就不执行了，catch也抓不住。
3. 但是如果有 finally块的话，那么，finally 几乎是必定会执行的，但是这里有一个先后顺序的问题，应该是 finally 块和 打印异常堆栈将会在另外一个线程之中执行，所以 打印的顺序就很有意思了。
4. 如果在try或者catch之中，执行System.exit(0); 那么 finally不会被执行，此外的情况，不管是Error还是return，finally块都会执行到。
5. 建议不清楚的拷贝代码或者自己写一份执行了看看。
### try-catch-finally 结构详解
#### 一、引言
`try-catch-finally` 结构是Java等编程语言中处理异常的核心机制之一。它允许开发者在编写程序时预见到可能出现的错误并采取相应的措施来处理这些错误，从而避免程序因未处理的异常而崩溃。
#### 二、try 的含义
`try` 块定义了一段可能抛出异常的代码区域。当`try` 块内的代码执行过程中遇到异常时，程序将跳过该异常发生后`try` 块内剩余的代码，并进入`catch` 块进行处理。如果`try` 块内没有异常发生，那么程序将按照正常流程执行完`try` 块内的所有代码。
#### 三、catch 的作用
`catch` 块用于捕获并处理由`try` 块抛出的异常。当`try` 块中发生异常时，程序会立即跳转至相应的`catch` 块。`catch` 块中可以包含一系列处理异常的代码，例如记录日志、用户提示等。如果没有与抛出异常匹配的`catch` 块，那么异常将继续向上传播，可能导致程序终止。
#### 四、finally 的功能
`finally` 块是`try-catch` 结构的一部分，用于确保无论是否发生异常，都必须执行的一段代码。即使`try` 或`catch` 块中包含`return` 语句或系统退出操作(`System.exit(0)`), `finally` 块也会被执行。这使得`finally` 成为了释放资源、关闭文件等操作的理想场所。
#### 五、try-catch-finally 的执行顺序
1. **正常执行**：如果`try` 块内的代码正常执行完毕（没有抛出异常），则执行`finally` 块。
2. **异常发生**：如果`try` 块内的代码抛出了异常，并且有对应的`catch` 块捕获了这个异常，那么先执行`catch` 块，然后执行`finally` 块。
3. **系统退出**：如果在`try` 或者`catch` 中调用了`System.exit(0)`，那么`finally` 块将不会被执行。
4. **内部异常**：如果`try` 块内抛出了`Error` 类型的异常（而非`Exception` 类型），那么`catch` 块无法捕获此类异常，`finally` 块仍然会被执行，但程序将不再继续执行后续的代码。
#### 六、示例分析
考虑以下示例代码：
```java
public class TestException {
boolean testEx() throws Exception {
boolean ret = true;
try {
ret = testEx1();
} catch (Exception e) {
System.out.println("testEx,catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx,finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception {
boolean ret = true;
try {
ret = testEx2();
if (!ret) {
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
} catch (Exception e) {
System.out.println("testEx1,catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx1,finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception {
boolean ret = true;
try {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
System.out.println("i=" + i);
}
return true;
} catch (Exception e) {
System.out.println("testEx2,catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx2,finally; return value=" + ret);
return ret;
}
}
public static void main(String[] args) {
TestException testException1 = new TestException();
try {
testException1.testEx();
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
这段代码中的`testEx2()` 方法在循环中执行除法运算。当循环变量`i` 变为0时，会出现`ArithmeticException`。此时，程序将按照以下步骤执行：
1. `testEx2()` 中的`try` 块抛出异常。
2. `testEx2()` 的`catch` 块捕获异常，并执行其中的代码。
3. `testEx2()` 的`finally` 块执行。
4. 异常继续向上抛出到`testEx1()` 的`catch` 块。
5. `testEx1()` 的`finally` 块执行。
6. 异常继续向上抛出到`testEx()` 的`catch` 块。
7. `testEx()` 的`finally` 块执行。
因此，正确的输出结果应为：
```
i=2
i=1
testEx2,catch exception
testEx2,finally; return value=false
testEx1,catch exception
testEx1,finally; return value=false
testEx,catch exception
testEx,finally; return value=false
```
这个例子展示了`try-catch-finally` 结构如何帮助开发者有效地控制和处理程序中的异常。通过合理地使用这些结构，可以增强程序的健壮性和可维护性。
