java异常

异常

异常认识

Java异常类层次结构

Throwable 是 Java 语言中所有错误与异常的超类。

Error 类及其子类：程序中无法处理的错误，表示运行应用程序中出现了严重的错误

Exception 程序本身可以捕获并且可以处理的异常。Exception 这种异常又分为两类：运行时异常和编译时异常。

运行时异常

运行时异常都是RuntimeException类及其子类异常

如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等

这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

非运行时异常

非运行时异常 （编译异常）是RuntimeException以外的异常，类型上都属于Exception类及其子类。

从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。

如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常

可查/不可查异常

可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）区别？

可查异常（编译器要求必须处置的异常）非运行时异常：正确的程序在运行中，很容易出现的、情理可容的异常状况。

可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。

这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

不可查异常(编译器不要求强制处置的异常)包括运行时异常 运行时异常（RuntimeException与其子类）和错误（Error）。

异常的基础代码

try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。

catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。

finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。

throw – 用于抛出异常。

throws – 用在方法签名中，用于声明该方法可能抛出的异常。

throw和throws的区别？

1.throws

在 Java 中，程序的执行始于 main 方法。每个执行的语句都在某个方法内。如果一个方法可能抛出可查异常（checked exception），那么必须在方法头中使用 throws 关键字声明该异常，以提醒调用者需要处理它。

public static void method() throws IOException, FileNotFoundException {
    // 方法内容
}

如果一个父类的方法没有声明异常，子类在覆盖时也不能声明异常。

异常处理的建议：

捕获异常：如果你知道如何处理某个异常，应该在方法内使用 try-catch 来捕获它。

传递异常：如果你不知道如何处理该异常，可以在方法签名中使用 throws 关键字将其抛出，让调用者处理。

例如，下面的 readFile 方法声明可能抛出 IOException：

private static void readFile(String filePath) throws IOException {
    File file = new File(filePath);
    String result;
    BufferedReader reader = new BufferedReader(new FileReader(file));
    while ((result = reader.readLine()) != null) {
        System.out.println(result);
    }
    reader.close();
}

关于 throws 的规则：

1. 可查异常：如果方法可能抛出可查异常，必须使用 throws 声明，或在方法内捕获它。
2. 不可查异常：对于 Error 和 RuntimeException 及其子类，可以不声明，虽然在运行时可能会抛出这些异常。
3. 覆盖方法：当子类覆盖父类方法时，不能声明与父类不同的异常。声明的异常必须是父类声明异常的同类或子类。

2.throw

如果代码可能会引发某种错误，可以创建一个合适的异常类实例并抛出它，这就是抛出异常。如下所示：

public static double method(int value) {
    if(value == 0) {
        throw new ArithmeticException("参数不能为0"); //抛出一个运行时异常
    }
    return 5.0 / value;
}

---

大部分情况下都不需要手动抛出异常，因为Java的大部分方法要么已经处理异常，要么已声明异常。所以一般都是捕获异常或者再往上抛。

有时我们会从 catch 中抛出一个异常，目的是为了改变异常的类型。多用于在多系统集成时，当某个子系统故障，异常类型可能有多种，可以用统一的异常类型向外暴露，不需暴露太多内部异常细节。

---

private static void readFile(String filePath) throws MyException {    
    try {
        // code
    } catch (IOException e) {
        MyException ex = new MyException("read file failed.");
        ex.initCause(e);
        throw ex;
    }
}

异常的自定义

习惯上，定义一个异常类应包含两个构造函数，一个无参构造函数和一个带有详细描述信息的构造函数（Throwable 的 toString 方法会打印这些详细信息，调试时很有用）, 比如上面用到的自定义MyException：

public class MyException extends Exception {
    public MyException(){ }
    public MyException(String msg){
        super(msg);
    }
    // ...
}

---

异常的捕获

异常捕获处理的方法通常有： try-catch try-catch-finally try-finally try-with-resource

try-catch

这是最常见的异常处理方式。在 try 块中放置可能抛出异常的代码，catch 块用于捕获并处理该异常。

try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 异常处理代码
}

try-catch-finally

这种方式在 try-catch 的基础上增加了 finally 块。无论 try 块中的代码是否抛出异常，finally 块中的代码都会执行，通常用于清理资源

try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 异常处理代码
} finally {
    // 无论是否有异常，都会执行的代码
}

try-finally

这种方式只包含 try 和 finally 块。如果 try 块中抛出异常，finally 块中的代码仍会被执行，但没有 catch 块来处理异常。

try {
    // 可能抛出异常的代码
} finally {
    // 无论是否有异常，都会执行的代码
}

finally遇见如下情况不会执行

• 在前面的代码中用了System.exit()退出程序。
• finally语句块中发生了异常。
• 程序所在的线程死亡。
• 关闭CPU。

try-with-resource

try-with-resource是Java 7中引入的，很容易被忽略。

finally 中的 close 方法也可能抛出 IOException, 从而覆盖了原始异常。

JAVA 7 提供了更优雅的方式来实现资源的自动释放，自动释放的资源需要是实现了 AutoCloseable 接口的类。

---

private  static void tryWithResourceTest(){
    try (Scanner scanner = new Scanner(new FileInputStream("c:/abc"),"UTF-8")){
        // code
    } catch (IOException e){
        // handle exception
    }
}

• 看下Scanner

public final class Scanner implements Iterator<String>, Closeable {
  // ...
}
public interface Closeable extends AutoCloseable {
    public void close() throws IOException;
}

try 代码块退出时，会自动调用 scanner.close 方法，和把 scanner.close 方法放在 finally 代码块中不同的是，若 scanner.close 抛出异常，则会被抑制，抛出的仍然为原始异常。被抑制的异常会由 addSusppressed 方法添加到原来的异常，如果想要获取被抑制的异常列表，可以调用 getSuppressed 方法来获取

---

常见的异常

异常实践

对异常的处理

1.只针对不正常的情况才使用异常

在 finally 块中清理资源或者使用 try-with-resource 语句

当使用类似InputStream这种需要使用后关闭的资源时，一个常见的错误就是在try块的最后关闭资源。

public void doNotCloseResourceInTry() {
    FileInputStream inputStream = null;
    try {
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file);
        // use the inputStream to read a file
        // do NOT do this
        inputStream.close();
    } catch (FileNotFoundException e) {
        log.error(e);
    } catch (IOException e) {
        log.error(e);
    }
}

• 方法一：使用 finally 代码块

public void closeResourceInFinally() {
    FileInputStream inputStream = null;
    try {
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file);
        // use the inputStream to read a file
    } catch (FileNotFoundException e) {
        log.error(e);
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                log.error(e);
            }
        }
    }
}

• 方法二：Java 7 的 try-with-resource 语法

如果你的资源实现了 AutoCloseable 接口，你可以使用这个语法。大多数的 Java 标准资源都继承了这个接口。当你在 try 子句中打开资源，资源会在 try 代码块执行后或异常处理后自动关闭。

---

如果你的资源实现了 AutoCloseable 接口，你可以使用这个语法。大多数的 Java 标准资源都继承了这个接口。当你在 try 子句中打开资源，资源会在 try 代码块执行后或异常处理后自动关闭。

尽量使用标准的异常

对异常进行文档说明

优先捕获最具体的异常

不要捕获 Throwable 类

不要忽略异常

不要记录并抛出异常

包装异常时不要抛弃原始的异常

不要使用异常控制程序的流程

不应该使用异常控制应用的执行流程，例如，本应该使用if语句进行条件判断的情况下，你却使用异常处理，这是非常不好的习惯，会严重影响应用的性能。

不要在finally块中使用return。

深入理解异常

JVM理解

提到JVM处理异常的机制，就需要提及Exception Table，以下称为异常表。我们暂且不急于介绍异常表，先看一个简单的 Java 处理异常的小例子。

public static void simpleTryCatch() {
   try {
       testNPE();
   } catch (Exception e) {
       e.printStackTrace();
   }
}

Exception table，异常表。异常表中包含了一个或多个异常处理者(Exception Handler)的信息，这些信息包含如下from 可能发生异常的起始点to 可能发生异常的结束点target 上述from和to之前发生异常后的异常处理者的位置type 异常处理者处理的异常的类信息

答案是异常发生的时候，当一个异常发生时

• 1.JVM会在当前出现异常的方法中，查找异常表，是否有合适的处理者来处理
• 2.如果当前方法异常表不为空，并且异常符合处理者的from和to节点，并且type也匹配，则JVM调用位于target的调用者来处理。
• 3.如果上一条未找到合理的处理者，则继续查找异常表中的剩余条目
• 4.如果当前方法的异常表无法处理，则向上查找（弹栈处理）刚刚调用该方法的调用处，并重复上面的操作。
• 5.如果所有的栈帧被弹出，仍然没有处理，则抛给当前的Thread，Thread则会终止。
• 6.如果当前Thread为最后一个非守护线程，且未处理异常，则会导致JVM终止运行。

以上就是JVM处理异常的一些机制。

try catch -finally

除了简单的try-catch外，我们还常常和finally做结合使用。比如这样的代码

public static void simpleTryCatchFinally() {
   try {
       testNPE();
   } catch (Exception e) {
       e.printStackTrace();
   } finally {
       System.out.println("Finally");
   }
}

finally是如何保证自己一定被执行的

正常情况下。执行完后调转到41

异常情况。从异常表跳到14 如果异常内正常执行 就跳到41

如果异常内发生错误14-19 就跳转到31执行finally

cathc问题

异常表越靠前，就越先被捕获

return和finally

都会执行

还是三种情况
正常情况下。 拷贝1
异常情况。异常内有异常 跳转拷贝
异常正常执行情况 拷贝

异常耗时

newException() 方法：
这个方法创建了testTimes个Exception实例。
与Object不同，Exception类包含了一些额外的字段和方法，用于存储异常信息、堆栈跟踪等。
创建Exception对象时，JVM需要分配更多的内存，并可能执行一些初始化操作，比如设置异常消息和堆栈跟踪。
这些额外的操作使得创建Exception对象比创建Object对象要慢。
3.
catchException() 方法：
这个方法不仅创建了testTimes个Exception对象，还抛出了它们并捕获。
抛出异常涉及到在调用栈中查找合适的异常处理器，这需要遍历调用栈并检查每个方法是否有匹配的catch块。
捕获异常时，JVM需要执行catch块中的代码，这可能包括记录日志、清理资源等操作。
这些操作比仅仅创建对象要复杂得多，因此这个方法执行起来最慢。

https://www.iteye.com/blog/icyfenix-857722