JavaSE之认识异常

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            System.out.println(array[5]);
            System.out.println("haha");//此处不能被打印
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("捕捉到一个数组越界异常");
        }
        System.out.println("hehe");
    }
}

编译并运行该代码，输出如下：

捕捉到一个数组越界异常
hehe 

其实ArrayIndexOutOfBoundsException是一个类 

2、一些注意事项

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            System.out.println(array[5]);
            System.out.println("haha");
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            System.out.println("捕捉到一个数组越界异常");
        }
        System.out.println("hehe");
    }
}

编译并运行该代码，输出如下：

 我们再举个例子;

import java.util.Scanner;
 
public class TestDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(n);
    }
}

 编译并运行该代码，输出如下：

 （2）catch 只能处理对应种类的异常

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            array = null;
            System.out.println(array[2]);
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            System.out.println("捕捉到一个数组越界异常");
        }
        System.out.println("hehe");
    }
}

  编译并运行该代码，输出如下：

此时, catch 语句不能捕获到刚才的空指针异常. 因为异常类型不匹配 

（3）catch 可以有多个

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            array = null;
            System.out.println(array[2]);
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            System.out.println("捕捉到一个数组越界异常");
        }catch (NullPointerException e){
            e.printStackTrace();
            System.out.println("捕捉到一个空指针异常");
        }
        System.out.println("hehe");
    }
}

  编译并运行该代码，输出如下：

如果多个异常的处理方式是完全相同, 也可以写成这样：

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            array = null;
            System.out.println(array[2]);
        }catch(ArrayIndexOutOfBoundsException | NullPointerException e){
            e.printStackTrace();
            System.out.println("捕捉到一个数组越界异常或者空指针异常");
        }
        System.out.println("hehe");
    }
}

 （4）也可以用一个 catch 捕获所有异常(不推荐)

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            array = null;
            System.out.println(array[2]);
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("发生异常");
        }
        System.out.println("hehe");
    }
}

   编译并运行该代码，输出如下：

 如果没有e.printStackTrace();这条语句，我们根本不知道发生了什么异常

import java.util.InputMismatchException;
import java.util.Scanner;
 
public class TestDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try{
            int n = scanner.nextInt();
            System.out.println(10/n);
        }catch(InputMismatchException e){
            e.printStackTrace();
            System.out.println("输出错误！");
        }catch(ArithmeticException e){
            e.printStackTrace();
            System.out.println("算术异常！");
        }finally{
            //finally一般用作资源的关闭，也可以不写finally，只写scanner.close();
            scanner.close();
        }
    }
}

无论是否存在异常 , finally 中的代码一定都会执行到 . 保证最终一定会执行到 Scanner 的 close 方法

（6）使用 try 负责回收资源

上面的代码可以有一种等价写法 , 将 Scanner 对象在 try 的 ( ) 中创建 , 就能保证在 try 执行完毕后自动调用 Scanner 的 close 方法

import java.util.InputMismatchException;
import java.util.Scanner;
 
public class TestDemo {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int n = scanner.nextInt();
            System.out.println(10 / n);
        } catch (InputMismatchException e) {
            e.printStackTrace();
            System.out.println("输出错误！");
        } catch (ArithmeticException e) {
            e.printStackTrace();
            System.out.println("算术异常！");
        }
    }
}

tip:

IDEA 能自动检查我们的代码风格, 并给出一些更好的建议. 如我们之前写的代码, 在 try 上有一个 "加深底色" , 这时 IDEA 针对我们的

代码提出了一些更好的建议此时把光标放在 try 上悬停, 会给出原因. 按下 alt + enter, 会弹出一个改进方案的弹窗. 我们选择其中的

replace with 'try' with resources此时我们的代码就自动被 IDEA 调整成上面的样子

（7）异常会沿着异常的信息调用栈进行传递

public class TestDemo {
    public static void func() {
        int[] arr = {1, 2, 3};
        System.out.println(arr[100]);
    }
    public static void main(String[] args) {
        try {
            func();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
    System.out.println("after try catch");
    }
}

编译并运行该代码，输出如下：

 如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止

3.异常处理流程

• 程序先执行 try 中的代码
• 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
• 如果找到匹配的异常类型, 就会执行 catch 中的代码
• 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
• 无论是否找到匹配的异常类型, fifinally 中的代码都会被执行到(在该方法结束之前执行).
• 如果上层调用者也没有处理的了异常, 就继续向上传递.
• 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止

4.抛出异常

除了 Java 内置的类会抛出一些异常之外 , 程序猿也可以手动抛出某个异常 . 使用 throw 关键字完成这个操作、

public class TestDemo {
    public static int divide(int x, int y) {
        if (y == 0) {
            throw new ArithmeticException("抛出除 0 异常");
            //我们可以根据实际情况来抛出需要的异常. 在构造异常对象同时可以指定一些描述性信息
        }
        return x / y;
    }
    public static void main(String[] args) {
        System.out.println(divide(10, 0));
    }
}

5.异常说明

我们在处理异常的时候 , 通常希望知道这段代码中究竟会出现哪些可能的异常 . 我们可以使用 throws 关键字 , 把可能抛出的异常显式的标注在方法定义的位置 . 从而提醒调用者要注意捕获这些异常

如：上面的代码可以写成这样

public class TestDemo {
    public static int divide(int x, int y) throws ArithmeticException {
        if (y == 0) {
            throw new ArithmeticException("抛出除 0 异常");
            //我们可以根据实际情况来抛出需要的异常. 在构造异常对象同时可以指定一些描述性信息
        }
        return x / y;
    }
    public static void main(String[] args) {
        System.out.println(divide(10, 0));
    }
}

6.关于finally的注意事项

public class TestDemo {
    public static int func() {
        try {
            return 10;
        }catch(ArithmeticException e){
            e.printStackTrace();
        }finally{
            return 20;
        }
    }
    public static void main(String[] args) {
        System.out.println(func());
    }
}

编译并运行该代码，输出如下：

20

finally 执行的时机是在方法返回之前 (try 或者 catch 中如果有 return 会在这个 return 之前执行 finally). 但是如果finally 中也存在 return 语句 , 那么就会执行 fifinally 中的 return, 从而不会执行到 try 中原有的 return. 一般我们不建议在 fifinally 中写 return ( 被编译器当做一个警告 ).

四、Java异常体系

下图表示 Java 内置的异常类之间的继承关系 :

• 顶层类 Throwable 派生出两个重要的子类, Error 和 Exception
• 其中 Error 指的是 Java 运行时内部错误和资源耗尽错误. 应用程序不抛出此类异常. 这种内部错误一旦出现， 除了告知用户并使程序终止之外, 再无能无力. 这种情况很少出现.
• Exception 是我们程序猿所使用的异常类的父类.
• 其中 Exception 有一个子类称为 RuntimeException , 这里面又派生出很多我们常见的异常类NullPointerException ,IndexOutOfBoundsException 等
• Java 语言规范将派生于 Error 类或 RuntimeException 类的所有异常称为 非受查异常 , 所有的其他异常称为 受查 异常

如果一段代码可能抛出 受查异常 , 那么必须显式进行处理，如：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
 
public class TestDemo {
    public static String readFile() {
        // 尝试打开文件, 并读其中的一行.
        File file = new File("d:/test.txt");
        // 使用文件对象构造 Scanner 对象.
        Scanner sc = new Scanner(file);
        return sc.nextLine();
    }
    public static void main(String[] args) {
        System.out.println(readFile());
    }
}

编译并运行该代码，输出如下： 

编译出错了，显式处理的方式有两种:

（1）在方法上加上异常说明, 相当于将处理动作交给上级调用者  

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
 
public class TestDemo {
    public static String readFile() throws FileNotFoundException {
        // 尝试打开文件, 并读其中的一行.
        File file = new File("d:/test.txt");
        // 使用文件对象构造 Scanner 对象.
        Scanner sc = new Scanner(file);
        return sc.nextLine();
    }
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println(readFile());
    }
}

（2）使用 try catch 包裹起来 

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
 
public class TestDemo {
    public static String readFile(){
        File file = new File("d:/test.txt");
        Scanner sc = null;
        try {
            sc = new Scanner(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return sc.nextLine();
    }
    public static void main(String[] args) {
        System.out.println(readFile());
    }
}

五、自定义异常类  

class NameException extends RuntimeException{
    public NameException(String name){
        super(name);
    }
}
class PasswordException extends RuntimeException{
    public PasswordException(String password){
        super(password);
    }
}
public class TestDemo {
    private static final String name = "xiaoxiao";
    private static final String passwords = "123456";
 
    public static void login(String name,String password) throws NameException,PasswordException{
        if(!TestDemo.name.equals(name)){
            //System.out.println("用户名错误！");
            throw new NameException("用户名错误！");//如果这里括号里什么都不加，上面就不用重写构造方法
        }
        if(!TestDemo.passwords.equals(password)){
            //System.out.println("密码错误！");
            throw new PasswordException("密码错误！");
        }
    }
    public static void main(String[] args) {
        try{
            login("xiaoxiao","12356");
        }catch(NameException e){
            e.printStackTrace();
            System.out.println("用户名错误！");
        }catch(PasswordException e){
            e.printStackTrace();
            System.out.println("密码错误！");
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        int i = 0;
        while(i < 10){
            try{
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("尝试连接网络第"+i+"次......");
                i++;
            }
        }
        System.out.println("终于有网了！");
    }
}