Java中的异常

一、之前笔记

1.Java中的异常分为必须处理的异常和可以不处理的异常
(1)必须处理的异常
① 自己处理：
　　try {
　　　　可能导致异常出现的代码
　　} catch (异常类型 e) {
　　　　捕捉到异常后的处理代码
　　} finally {
　　　　无论是否出现异常都会执行的代码 //注意一定会执行，可能导致逻辑上的错乱。
　　}

② 让别人处理：throws
　　public static int div(int m, int n) throws(异常类型1) {
　　　　可能出异常类型1的代码
　　}

③ 有些异常需要自己处理一部分后使用throw再次抛出这个异常，外部也做相应的处理。

(2)可以不处理的异常，比如runtime异常，至少可以编译过。而可见查异常编译都无法过，必须要在代码中try catch处理或者throws这个异常。

2.可以先捕获具体的可能出现的运行时异常，但是由于运行时异常有很多，可能不可能都列出来捕获完此时可以最后捕获父类运行时异常，这样所有的运行时异常都可以捕获到了。运行时异常作为父类应该放在最后一个catch()里面，否则会覆盖前面的子类的异常。

3.若 try catch 语句块里面有throw或return语句的话会先执行finally语句块，然后再返回来执行throw或return语句。(若finally语句块中也有return语句，那么就直接退出了，不会再返回去执行throw或return语句了，因此尽量避免在finally中return) 。

补充：原理是会把 try/catch 中的return值保存到一个临时变量中，当 finally 语句执行完后再返回这个临时变量的值，因此就算是再finally语句中更改了返回的那个值的大小也不会影响返回结果，因为要返回的值已经提前保存在临时变量中了。若是finally语句中更改了返回变量的值，那就会体现在返回结果上，因为返回的就是它。可参考：“try catch 底层原理”

4.优秀博文：http://blog.csdn.net/hguisu/article/details/6155636 <未看>

5.如果不处理异常，一旦异常发生时程序会退出。

6.在JDK API的chm手册中的Integer类中有将命令行参数转换为int的方法。先检索Integer然后在它里面找parseInt()方法。使用JDK提供的方法不需要import包。

7.try catch的异常就是串口打印的异常类型，也就是串口报什么异常就在catch()中写成什么异常。

8.可检查异常和不可查异常(运行时异常)

9.若函数内没有处理异常，那么异常将会一层一层地往上抛，无论函数签名后是否有throws exceptionType.
public static int div(int m, int n) throws ArithmeticException {　　//若函数内部没有处理这个异常，这里写不写throws都会抛出给上层函数
　　int r = m / n;
　　return r;
}

10.函数内部(catch)处理异常后,函数外部就不会再收到异常了。除非catch语句块中再次throw出异常。即便是函数头上加throws ArithmeticException也不会抛出此异常，因为此异常在函数内部已经处理了。

11.其实函数内部throw的异常函数内部也是可以捕捉的，此时此函数就不会因调用throw而返回退出。
　　try {
　　　　throw new Exception("My Error");
　　} catch (Exception e2) {
　　　　System.out.println("div :"+ e2);
　　}

12.方法内部throw Exception必须自己catch()或者声明被抛出方法外

error: unreported exception Exception; must be caught or declared to be thrown
        throw new Exception("Invalid Arguement");
        ^
public void addNode(Node node) {
    throw new Exception("Invalid Arguement");
}
//修正：
public void addNode(Node node) throws Exception {
    throw new Exception("Invalid Arguement");        //注意这里是throw,上面是throws!
}

之后若每一层父级调用只要没有使用try...catch来捕获异常，都要在函数声明处加throws Exception！

 

13. 试验Demo

/* java Div 6 2
 * 6/2=3
 */

public class Div9 {

    public static void main(String args[]) {
        int m = 0;
        int n = 0;
        int r = 0;
        
        System.out.println("Begin of div");
        try {
            m = Integer.parseInt(args[0]);
            n = Integer.parseInt(args[1]);
            r = div(m, n);
        } catch (ArithmeticException e) {
            System.out.println("main :"+e);
        } catch (NumberFormatException e) {
            System.out.println("main :"+e);
        } catch (RuntimeException e) {
            System.out.println("main :"+e);
        }
        System.out.println("End of div");

        System.out.println(m+"/"+n+"="+r);
        
    }

//    public static int div(int m, int n) throws ArithmeticException {
    public static int div(int m, int n) {    // also the same    
        int r = 0;

        try {
            r = m / n;
        } catch (ArithmeticException e) {
            System.out.println("div :"+e);
            throw e;
        } finally {
            System.out.println("finally of div");
            //return r;
        }
        return r;
    }
}

 

二、补充-chatgpt

在Java中，通过使用throw关键字来实现抛出异常。这是一种控制流程的机制，用于在程序执行过程中遇到不可处理或错误的情况时，中断当前的执行路径，并可以将错误信息传递给调用栈的上层。

1. 抛出异常的语法

基本语法：throw new ExceptionType("异常信息");

ExceptionType 是异常的类型，可以是Java标准库中的异常类，如 IllegalArgumentException, NullPointerException 等，也可以是自定义的异常类。

"异常信息"是一个字符串，用于描述异常的具体情况，便于调试和问题定位。

2. 实现过程

当程序执行到throw语句时，会立即停止当前方法的执行（除非被try-catch块捕获）。

程序会寻找最近的包围该点的 try-catch 块来处理这个异常。如果找到了合适的 catch 块，程序会跳转到该 catch 块执行。

如果没有找到合适的处理代码，该异常会被抛给调用该方法的方法，这个过程会一直回溯到调用栈的顶层，直到找到处理该异常的catch块，或者导致程序终止（如果主线程抛出未被捕获的异常）。

3. 示例

public class ExceptionTest {
    public static void divideNumbers(int numerator, int denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        int result = numerator / denominator;
        System.out.println("结果是: " + result);
    }

    public static void main(String[] args) {
        try {
            divideNumbers(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("发生错误：" + e.getMessage());
        }
    }
}

/*
 * /tmp_161/3.java_test/7.Exception$ java ExceptionTest
 * 发生错误：除数不能为0
 */

在这个例子中，当 denominator 为0时，divideNumbers 方法会抛出一个 ArithmeticException。在main方法中，我们通过 try-catch 块捕获并处理了这个异常，避免了程序的意外终止。

4. 方法签名中的throws

在方法签名中使用 throws ExceptionType 声明可能抛出的异常，告诉调用者这个方法可能抛出特定类型的异常，调用者必须处理这些异常或再次声明抛出。

这是一种异常的传递机制，使得异常处理的责任可以逐级向上层方法转移。

5. 自定义异常

开发者可以根据需要创建自己的异常类，通常继承自 Exception 或其子类，以更精确地表示特定的错误情况。

通过这种方式，Java的异常处理机制提供了一种健壮的错误处理方式，确保程序在遇到错误时能够优雅地处理，而不是直接崩溃。