当代码抛出一个异常时， 就会终止方法中剩余代码的处理，并退出这个方法的执行。如果方法获得了一些本地资源，并且只有这个方法自己知道，又如果这些资源在退出方法之前必须被回收，那么就会产生资源回收问题。一种解决方案是捕获并重新抛出所有的异常，这种解决方案并不完美，这是因为需要在两个地方清除所分配的资源。一个在正常的代码中；另一个在异常代码中。
Java 有一种更好的解决方案，这就是 finally 子句。下面将介绍 Java 中如何恰当地关闭一个文件。如果使用 Java 编写数据库程序，就需要使用同样的技术关闭与数据库的连接。当发生异常时，关闭所有数据库的连接是非常重要的。不管是否有异常被捕获，finally 子句中的代码都被执行。在下面的示例中， 程序将在所
有情况下关闭文件：
InputStream in = new FileInputStream(. . .);
try{
code that might throwexceptions
}catch (IOException e) { // 3
showerror message
// 4
}finally{ // 5
in.close()；
}
在上面这段代码中，有下列 3 种情况会执行 finally 子句：
1 ) 代码没有抛出异常。 在这种情况下， 程序首先执行 try 语句块中的全部代码，然后执行 finally 子句中的代码t 随后， 继续执行 try 语句块之后的第一条语句。也就是说，执行标注的 1、 2、 5、 6 处。
2 ) 抛出一个在 catch 子句中捕获的异常。在上面的示例中就是 IOException 异常。在这种情况下，程序将执行 try语句块中的所有代码，直到发生异常为止。此时，将跳过 try语句块中的剩余代码，转去执行与该异常匹配的 catch 子句中的代码， 最后执行 finally 子句中的代码。如果 catch 子句没有抛出异常，程序将执行 try 语句块之后的第一条语句。在这里，执行标注 1、 3、 4、5、 6 处的语句。如果 catch 子句抛出了一个异常， 异常将被抛回这个方法的调用者。在这里， 执行标注1、 3、 5 处的语句。
3 ) 代码抛出了一个异常， 但这个异常不是由 catch 子句捕获的。在这种情况下，程序将执行 try 语句块中的所有语句，直到有异常被抛出为止。此时， 将跳过 try 语句块中的剩余代码， 然后执行 finally 子句中的语句， 并将异常抛给这个方法的调用者。在这里， 执行标注 1、 5 处的语句。
try 语句可以只有 finally 子句，而没有 catch 子句。例如，下面这条 try 语句：
InputStream in = . .
try{
code that might throwexceptions
}finally{
in.close()；
}
警告：当 finally 子句包含 return 语句时， 将会出现一种意想不到的结果„ 假设利用 return语句从 try语句块中退出。在方法返回 前，finally 子句的内容将被执行。如果 finally 子句中也有一个 return 语句，这个返回值将会覆盖原始的返回值。如：
public static int f(int n) {
try{
int r = n * n;
return r;
}finally{
if (n = 2) return 0;
}
}
如果调用 f(2), 那么 try 语句块的计算结果为 r = 4, 并执行 return 语句然而，在方法真正返回前，还要执行 finally 子句。finally 子句将使得方法返回 0, 这个返回值覆盖了原始的返回值 4
======================================================================
使用throws声明抛出异常的思路是：当前方法不知道如何处理这种类型的异常，该异常应该由上一级调用者处理；如果main方法也不知道如何处理该类型的异常，也可以使用throws声明抛出异常，该异常交给JVM处理，JVM对异常的处理方法是：打印异常的跟踪栈信息，并终止程序运行。
throws只能在方法签名中使用，throws可以声明抛出多个异常类，多个异常类之间以逗号隔开：
throws ExceptionClass1,ExceptionClass2 …………
ThrowsTest.java
public class ThrowsTest{
public static void main(String[] args) throws Exception{
// 因为test()方法声明抛出IOException异常，
// 所以调用该方法的代码要么处于try…catch块中，
// 要么处于另一个带throws声明抛出的方法中。
test();
}
public static void test()throws IOException{
// 因为FileInputStream的构造器声明抛出IOException异常，
// 所以调用FileInputStream的代码要么处于try…catch块中，
// 要么处于另一个带throws声明抛出的方法中。
FileInputStream fis = new FileInputStream(“a.txt”);
}
}
如果需要在程序中自行抛出异常，则应使用 throw 语句。throw 吾句可以单独使用，throw 语句抛出的不是异常类，而是一个异常实例，而且每次只能抛出一个异常实 throw 语句的语法格式如下:
throw ExceptionInstance ;
ThrowTest.java
public class ThrowTest{
public static void main(String[] args){
try{
// 调用声明抛出Checked异常的方法，要么显式捕获该异常
// 要么在main方法中再次声明抛出
throwChecked(-3);
}catch (Exception e){
System.out.println(e.getMessage());
}
// 调用声明抛出Runtime异常的方法既可以显式捕获该异常，
// 也可不理会该异常
throwRuntime(3);
}
public static void throwChecked(int a)throws Exception{
if (a > 0){
// 自行抛出Exception异常
// 该代码必须处于try块里，或处于带throws声明的方法中
throw new Exception(“a的值大于0，不符合要求”);
}
}
public static void throwRuntime(int a){
if (a > 0){
// 自行抛出RuntimeException异常，既可以显式捕获该异常
// 也可完全不理会该异常，把该异常交给该方法调用者处理
throw new RuntimeException(“a的值大于0，不符合要求”);
}
}
}
在程序中，可能会遇到任何标准异常类都没有能够充分地描述清楚的问题。 在这种情况下，可以自定义异常类。
是定义一个派生于Exception 的类，或者派生于 Exception 子类的类。例如， 定义一个派生于 IOException 的类。
习惯上， 定义的类应该包含两个构造器， 一个是默认的构造器；另一个是带有详细描述信息的构造器（超类 Throwable 的 toString 方法将会打印出这些详细信息， 这在调试中非常有用)。
class FileFormatException extends IOException{
public FileFormatExceptionO {}
public FileFormatException(String gripe) {
super(gripe);
}
接下来，就可以抛出自定义的异常类型：
String readData(BufferedReader in) throws FileFormatException{
while (. . .) {
if (ch == -1){ // EOF encountered
if (n < len){
throw new FileFornatException();
}
}
}
对于真实的企业级应用而言，常常有严格的分层关系，层与层之间有非常清晰的划分，上层功能的实现严格依赖于下 API，也不会跨层访问：
图三：MVC三层结构
当业务逻辑层访问持久层出现
SQLException 异常时， 程序不应该把底层的 SQLException 异常传到用户界面，
有如下两个原因。
-
对 于 正 常 用 户 而 言 ， 他 们不想看到底层 SQLException异常，SQLException 异常对他们使用该系统没有任何帮助。
-
对于恶意用户而言， 将 SQLException 异常暴露出来不安全
把底层的原始异常直接传给用户是一种不负责任的表现。 通常的做法是:程序先捕获原始异常， 然后抛出一个新的业务异常， 新的业务异常中包含了对用户的提示信息， 这种处理方式被称为异常转译。 假设程序需要实现工资计算的方法，
则程序应该采用如下结构的代码来实现该方法：
public void calSal() throws SalException{
try{
// 实现结算工资的业务逻辑
}catch(SQLException sqle){
// 把原始异常记录下来， 留给管理员
// 下面异常中的 message 就是对用户的提示
throw new SalException(“访问底层数据库出现异常”）;
} catch(Exception e)
// 把原始异常记录下来， 留给管理员
// 下面异常中的 message 就是对用户的提示
throw new SalException( “系统出现未知异常”）;
}
}
============================================================================
异常对象的 printStackTrace()方法用于打印异常的跟踪栈信息， 根据 printStackTrace()方法的输出结果， 开发者可以找到异常的源头， 并跟踪到异常一路触发的过程。
PrintStackTraceTest.java
class SelfException extends RuntimeException
{
SelfException(){}
SelfException(String msg)
{
super(msg);
}
}
public class PrintStackTraceTest
{
public static void main(String[] args)
{
firstMethod();
}
public static void firstMethod()
{
secondMethod();
}
public static void secondMethod()
{
thirdMethod();
}
public static void thirdMethod()
{
throw new SelfException(“自定义异常信息”);
}
}
运行结果：
异常从thirdMethod方法开始触发 ， 传到 secondMethod 方法，再传到firstMethod 方法， 最后传到 main 方法， 在 main 方法终止， 这个过程就是 Java 的异常跟踪栈。
面向对象的应用程序运行时， 经常会发生一系列方法调用， 从而形成“ 方法调用栈”， 异常的传播则相反： 只要异常没有被完全捕获（ 包括异常没有被捕获， 或异常被处理后重新抛出了新异常），异常从发生异常的方法逐渐向外传播， 首先传给该方法的调用者， 该方法调用者再次传给其调用者……直至最后传到 main 方法， 如果 main 方法依然没有处理该异常， JVM 会中止该程序， 并打印异常的跟踪栈信息。
图中所示的异常跟踪栈信息非常清晰——它记录了应用程序中执行停止的各个点：
第一行的信息详细显示了异常的类型和异常的详细消息。
接下来跟踪栈记录程序中所有的异常发生点， 各行显示被调用方法中执行的停止位置， 并标明类、类中的方法名、 与故障点对应的文件的行。
一行行地往下看， 跟踪栈总是最内部的被调用方法逐渐上传，直到最外部业务操作的起点， 通常就是程序的入口 main 方法或 Thread 类的 rim 方法（ 多线程的情形）。
===========================================================================
下面给出使用异常机制的几个技巧:
1. 异常处理不能代替简单的测试
作为一个示例， 在这里编写了一段代码， 试着上百万次地对一个空栈进行退栈操作。在实施退栈操作之前， 首先要查看栈是否为空。
if (!s.empty()) s.popO;
接下来，强行进行退栈操作。然后， 捕获 EmptyStackException 异常来告知我们不能这样做。
try{
s.pop();
}catch (EmptyStackException e) {
}
在测试的机器上， 调用 isEmpty 的版本运行时间为 646 毫秒。捕获 EmptyStackException 的版本运行时间为 21 739 毫秒。
可以看出，与执行简单的测试相比， 捕获异常所花费的时间大大超过了前者， 因此使用异常的基本规则是：只在异常情况下使用异常机制。
2. 不要过分地细化异常
很多程序员习惯将每一条语句都分装在一个独立的 try语句块中。
PrintStream out;
Stack s;
for (i = 0;i < 100; i++) {
try
{ n = s.pop(); }
catch (EmptyStackException e) {
II stack was empty
}
try
{
out.writelnt(n); }
catch (IOException e) {
ff problem writing to file
} }
这种编程方式将导致代码量的急剧膨胀。首先看一下这段代码所完成的任务。在这里，希望从栈中弹出 100 个数值， 然后将它们存人一个文件中。如果栈是空的， 则不会变成非空状态；如果文件出现错误， 则也很难给予排除。出现上述问题后，这种编程方式无能为力。因此，有必要将整个任务包装在一个 try语句块中，这样， 当任何一个操作出现问题时， 整个任务都可以取消。
try
{
for (i = 0; i < 100; i++) { n = s.popO ;
out.writelnt(n); } }
catch (IOException e) { // problem writing to file
}
catch (EmptyStackException e) { f] stack was empty
}
分享
这次面试我也做了一些总结，确实还有很多要学的东西。相关面试题也做了整理，可以分享给大家，了解一下面试真题，想进大厂的或者想跳槽的小伙伴不妨好好利用时间来学习。学习的脚步一定不能停止！
Spring Cloud实战
Spring Boot实战
面试题整理（性能优化+微服务+并发编程+开源框架+分布式）
在这里，希望从栈中弹出 100 个数值， 然后将它们存人一个文件中。如果栈是空的， 则不会变成非空状态；如果文件出现错误， 则也很难给予排除。出现上述问题后，这种编程方式无能为力。因此，有必要将整个任务包装在一个 try语句块中，这样， 当任何一个操作出现问题时， 整个任务都可以取消。
try
{
for (i = 0; i < 100; i++) { n = s.popO ;
out.writelnt(n); } }
catch (IOException e) { // problem writing to file
}
catch (EmptyStackException e) { f] stack was empty
}
分享
这次面试我也做了一些总结，确实还有很多要学的东西。相关面试题也做了整理，可以分享给大家，了解一下面试真题，想进大厂的或者想跳槽的小伙伴不妨好好利用时间来学习。学习的脚步一定不能停止！
[外链图片转存中…(img-AKzaIPT0-1714306853503)]
Spring Cloud实战
[外链图片转存中…(img-lB4oNXPD-1714306853504)]
Spring Boot实战
[外链图片转存中…(img-InJ2x5Oe-1714306853505)]
面试题整理（性能优化+微服务+并发编程+开源框架+分布式）
159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
