int[] arr = null;
        System.out.println(arr.length);

try{
   // 可能会发生异常的代码
}catch(异常类型 e){
   // 对捕获到的异常进行处理
}finally{
   // 此处的语句无论是否发生异常，都会被执行到
}

// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

        Scanner scan = new Scanner(System.in);
        try{
            int n = scan.nextInt();
            System.out.println("抛出异常之前的代码可以被执行");
            System.out.println(10/n);
            System.out.println("抛出异常之后的代码不会被执行");
        }catch(ArithmeticException a){
            a.printStackTrace();//打印异常的详细信息
            System.out.println("这是算术异常");
        }
        //多个异常的处理方式是完全相同,中间可以用 | 隔开
        catch(ArrayIndexOutOfBoundsException | NullPointerException n){
            n.printStackTrace();
            System.out.println("这是数组越界异常和空指针异常");
        }
        //通过一个catch捕获所有的异常，即多个异常
        catch (Exception e){
            e.printStackTrace();
            System.out.println("这是异常");
        }
        //finally中的代码一定会执行的，不管是否发生异常
        finally {
            System.out.println("finally中的代码一定会被执行");
            scan.close();
        }
        System.out.println("该代码在没有抛出异常或异常被捕获执行，异常未处理不执行");

    public static int meth(){
        try{
            System.out.println(10/0);
            return 0;
        }catch(ArithmeticException a){
            return 1;
        }finally{
            return 2;
        }
    }
    public static void main(String[] args) {
        System.out.println(meth());// 输出：2
    }

在 finally 中使用 return 是不推荐的，因为：

1. 容易混淆逻辑：掩盖了 try 或 catch 的返回结果。
2. 难以调试：可能会导致不可预测的行为，特别是在处理资源释放时。

异常的处理流程

关于 " 调用栈 "

方法之间是存在相互调用关系的 , 这种调用关系我们可以用 " 调用栈 " 来描述 . 在 JVM 中有一块内存空间称为

" 虚拟机栈 " 专门存储方法之间的调用关系 . 当代码中出现异常的时候 , 我们就可以使用 e.printStackTrace(); 的

方式查看出现异常代码的调用栈 .

【 异常处理流程总结 】

程序先执行 try 中的代码

如果 try 中的代码出现异常 , 就会结束 try 中的代码 , 看和 catch 中的异常类型是否匹配 .

如果找到匹配的异常类型 , 就会执行 catch 中的代码

如果没有找到匹配的异常类型 , 就会将异常向上传递到上层调用者 .

无论是否找到匹配的异常类型 , finally 中的代码都会被执行到 ( 在该方法结束之前执行 ).

如果上层调用者也没有处理的了异常 , 就继续向上传递 .

一直到 main 方法也没有合适的代码处理异常 , 就会交给 JVM 来进行处理 , 此时程序就会异常终止

自定义异常类

//自定义异常
//继承RuntimeException
public class NameException extends RuntimeException{
    //构造方法
    public NameException() {
    }

    public NameException(String message) {
        super(message);
    }
}

//自定义异常
//继承RuntimeException
public class PasswordException extends RuntimeException{
    //构造方法
    public PasswordException() {
    }

    public PasswordException(String message) {
        super(message);
    }
}

import java.util.Scanner;

public class Login{
    private String name = "admin";
    private String password = "123456";
    public void Loginifor(String name,String password){
        if(!this.name.equals(name)){
            throw new NameException("用户名输入错误,请重新输入用户名:");//抛出异常
        }
        if(!this.password.equals(password)){
            throw new PasswordException("密码输入错误,请重新输入密码:");//抛出异常
        }
        System.out.println("登录成功");
    }

    public static void main(String[] args) {
        Login login = new Login();
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入用户名:");
        String name1 = scan.nextLine();
        System.out.print("请输入密码:");
        String password1 = scan.nextLine();
        while(true){
            try{
                login.Loginifor(name1,password1);//可能会抛出异常
                break;//抛出异常后，该代码不被执行  输入正确后，跳出循环
            }catch (NameException n){ //捕获异常
                //处理异常
                n.printStackTrace();//打印异常
                name1=scan.nextLine();//重新输入用户名
            }catch (PasswordException p){
                p.printStackTrace();
                password1=scan.nextLine();
            }
        }
    }
}