什么是异常

Java是一种面向对象编程语言，提供了一种强大的异常处理机制。Java异常是一个事件，它发生在程序执行过程中导致程序中断或出错。当发生异常时，Java程序会自动创建一个异常对象来表示该异常，并将异常对象传递给相应的异常处理程序来处理。

Java异常机制的主要目的是使程序更加可靠，因为在发生异常时，程序并不会异常终止，而是将异常传递给异常处理程序来处理。Java异常处理机制提供了一种强大的工具，使得程序能够处理错误情况，以便程序可以回复并继续执行。在Java中，异常可以分为两种类型：受查异常和非受查异常。

受查异常

受查异常也叫编译异常，是指在编译时必须显式地声明抛出该异常，否则编译器将会报错。受查异常通常是程序可以预料到并可能解决的异常，例如文件不存在、网络连接异常等。如果程序在编译时没有正确地处理受查异常，将会导致编译错误。

下面是一个示例代码，它使用了Java的IOException异常，这是一种受查异常。

import java.io.*;
public class FileHandling {
   public static void main(String args[]) {
      try {
         File file = new File("file.txt");
         FileReader fr = new FileReader(file);
         BufferedReader br = new BufferedReader(fr);
         String line;
         while((line = br.readLine()) != null) {
            System.out.println(line);
         }
         br.close();
      } catch(IOException e) {
         e.printStackTrace();
      }
   }
}

在上面的代码中，我们通过FileReader读取文件内容，并使用BufferedReader逐行读取文件内容。由于读取文件时可能会发生异常，我们需要在try-catch块中捕获并处理IOException异常。

非受查异常

非受查异常是指在编译时无须声明抛出该异常。通常情况下，非受查异常是由于程序中出现了错误，例如除数为零、数组下标越界等，并且发生这些异常时，程序无法自行恢复。因此，非受查异常通常会导致程序异常终止。

在Java中，非受查异常包括RuntimeException及其子类，例如NullPointerException（空指针异常）、ArrayIndexOutOfBoundsException（数组越界异常）、ArithmeticException（除数为0异常）等。这些异常通常是程序出现逻辑错误时才会产生。

下面是一个示例代码，它使用了Java的ArithmeticException异常，这是一种非受查异常。

public class Example {
   public static void main(String args[]) {
      int a = 10, b = 0;
      try {
         int c = a / b;
         System.out.println("Result: " + c);
      } catch(ArithmeticException e) {
         System.out.println("Exception caught: " + e);
      }
   }
}

在上面的代码中，我们尝试将10除以0，这会导致ArithmeticException异常的发生。由于程序无法自行恢复该异常，我们需要在try-catch块中捕获并处理该异常。

当出现异常的时候，我们必须自己手动处理这些异常，否则这些异常就会交给JVM处理，如果交给JVM处理，那么程序就会异常终止。

举个不恰当的例子，当你犯事的时候，如果只是你的父母发现知道了，那么你的父母可能会帮助你解决问题并且不告诉警察；但是如果你的父母不知道，但是被警察知道了，那么你就会被法律制裁。

怎样处理异常

事前防御型异常

Java中的事前防御型异常（Proactive Defense）指的是在代码开发阶段预先考虑和处理异常情况，以提高应用程序的健壮性和稳定性。事前防御型异常意味着通过将异常情况纳入代码设计和实现过程，尽可能主动地防止异常情况的发生，而不仅是在异常发生后采取响应措施。

意思也就是说：我根本不给你犯罪的机会，从你有这个萌芽的时候就扼杀你。

  public static int length(String s) {
        if(s == null) {
            return -1;
        }
        return s.length();
    }
    public static void main(String[] args) {
        System.out.println(length("abdias"));
    }

当我们用length来求字符串的长度时（有点多此一举了啊），你想要访问null的时候，我直接终止这个length，不让你访问null。这就是事前防御型异常。

事后认错型异常

Java中的事后认错型异常（Post-mortem Defense）是指在应用程序运行时发生异常时采取的响应措施。如果应用程序无法避免发生异常情况，那么事后认错型异常就是在程序发生异常后对异常进行收集和处理，以恢复应用程序的稳定性和可靠性。

Java中可以使用try-catch-finally块来捕获和处理发生的异常。try块中包含可能会引发异常的代码，catch块用于捕获处理异常情况，finally块用于确保代码块中的资源得到释放（即使异常发生）。

try {
  可能会出现异常的代码块
}catch(捕获的异常) {
  处理异常
}finally {
  确保代码块中的资源得到释放
}

我们今天主要讲的就是事后认错型异常。

异常的抛出

我们使用throw关键字来抛出一个指定的异常对象。

  public static int length(String s) {
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
        }
        return s.length();
    }
    public static void main(String[] args) {
        System.out.println(length(null));
    }

这里会将你出错的位置给你指出来，方便改正。

我们再来思考一个问题，就是如果这里抛出异常了，那么当出现异常的时候，其后面的代码还会执行吗？

public static int length(String s,int a) {
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
            a = 20;
        }
        return s.length();
    }
    public static void main(String[] args) {
        int a = 10;
        System.out.println(length(null,a));
        System.out.println(a);
    }

这里标红了，我们将鼠标放上去，可以看到提示，提示这个语句是不可能达到的，也就是说，当你s指向的不为null时，if语句根本就进不去，如果s指向的是null时，程序也不会走到a = 20这个语句，所以抛出异常的语句如果出现了异常，那么后面的语句将不会执行。

注意事项

1. throw必须写在方法体内部

2. 抛出的对象必须是Exception 或者 Exception 的子类对象

3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理

4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译

5. 异常一旦抛出，其后的代码就不会执行

异常的捕获

throws捕获异常

当你在方法参数的后面使用throws异常类型时，表明你这个方法可能会出现此类异常，但是在此方法中不处理异常，只是告诉你调用者会出现异常，具体怎样处理，需要你调用者处理。

  public static int length(String s) throws NullPointerException{
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
        }
        return s.length();
    }
    public static void main(String[] args) {
        int a = 10;
        System.out.println(length(null));
        System.out.println(a);
    }

就先这样，我length方法只是告诉你出现了空指针异常，但是空指针异常解决了吗？并没有，所以我们在方法参数后面使用throws 异常类型只是告诉调用者会出现那种类型的异常，具体解决需要调用者解决。如果你调用者没有解决异常，那么就需要继续用throws抛出异常。

注意事项

1. throws必须跟在方法的参数列表之后

2. 声明的异常必须是 Exception 或者 Exception 的子类

3. 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。

如果我们想要解决这个异常该怎么办呢？

try-catch-finally捕获异常

try{
// 将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
// 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
}catch(异常类型 e){
// 对异常进行处理
}finally{
// 此处代码一定会被执行到
}
// 后序代码
// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行

当try中的代码出现异常的时候，catch就会捕获try中出现的异常，并且对应的catch捕获的异常类型是与try中抛出的异常类型一致，或者是try中抛出异常的基类，当某个catch捕获到了对应的异常时，如果catch中的代码块执行完后，就会跳出其他的catch捕获到finally（如果有），否则就到后续的代码块，也就是说catch只能捕获到一种异常。

public static int length(String s) throws NullPointerException{
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
        }
        return s.length();
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = null;
        int ret = 0;
        try {
            ret = length(str);
        }catch(NullPointerException e) {
          //e.printStackTrace将栈上出现的异常给打印出来
            e.printStackTrace();
            System.out.println("传入的字符串为null，请重新输入");
            String tmp = scanner.nextLine();
            ret = length(tmp);
        }
        System.out.println(ret);
    }

注意事项

1. try块内抛出异常位置之后的代码将不会被执行

2. 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的。

3. try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获。

4. 可以通过一个catch捕获所有的异常，即多个异常，一次捕获(不推荐)

catch (ArrayIndexOutOfBoundsException | NullPointerException e) { ... }

5.如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误。

finally

finally中的代码是一定会被执行的，不管你的try中有没有出现异常，就算你在catch捕获异常并处理异常的时候return了，finally中的代码也是会出现在程序结束之前。

finally通常被用在网络连接数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

自定义异常类

当我们平时登录账号的时候，如果用户名或者密码错误的时候，我们又该抛出怎样的异常呢？

Java中提供了非受查类异常NullPointerException(空指针异常)、IndexOutOfBoundsException(数组越界异常)、IllegalArguementException(无效参数异常)、ClassCastException(类型转换异常)等。这些在我们的日常生活中显然是不能完全覆盖到的，所以就出现了自定义异常，我们可以自己定义异常。

当我们自定义异常类的时候，我们需要继承Exception类或者Exception的子RunTimeException，建议继承RunTimeException。

自定义异常通常会继承自 Exception 或者 RuntimeException

继承自 Exception 的异常默认是受查异常

继承自 RuntimeException 的异常默认是非受查异常

public class Main {
    private static String name = "zhangsan";
    private static String ps = "123456";
    public static void login(String name,String ps) {
        if(!Main.name.equals(name)) {
            throw new NameException("用户名错误");
        }
        if(!Main.ps.equals(ps)) {
            throw new PasswordException("密码错误");
        }
    }
    public static void main1(String[] args) throws NameException,PasswordException{
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的用户名和密码");
        String name  = scanner.nextLine();
        String ps = scanner.nextLine();
        try {
            login(name,password);
        }catch(NameException e) {
            e.printStackTrace();
        }catch(PasswordException e) {
            e.printStackTrace();
        }
    }
class NameException extends RuntimeException {
    public NameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException {
    public PasswordException(String message) {
        super(message);
    }
}

带你深入理解Java异常