【JavaSE】- 异常处理

1.1异常概念

常见的运行时异常包括

1. NullPointerException 空指针异常

        String name = null;
        System.out.println(name. Length());

2. ArithmeticException 数学运算异常

        int num1 = 10;
        int num2 = 0;//Scanner();
        try {
            int res = num1 / num2;
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println("出现异常的原因=" + e.getMessage());//输出异常信息
        }

        System.out.println("程序继续运行....");

3. ArrayIndexOutOfBoundsException 数组下标越界异常

        int[] arr = {1,2,4};
        for (int i = 0; i <= arr.length; i++) {
            System.out.println(arr[i]);
        }

4. ClassCastException 类型转换异常

        A b = new B(); //向上转型
        B b2 = (B)b;//向下转型，这里是OK
        C c2 = (C)b;//这里抛出ClassCastException
class A {}
class B extends A {}
class C extends A {}

5. NumberFormatException 数字格式不正确异常

        String name = "WYT";
        //将String 转成 int
        int num = Integer.parseInt(name);
        System.out.println(num);

1.2 编译异常

练习

1.3 异常处理的方式

2.1 try-catch

1. 如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块

        try {
            String str = "str";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
            System.out.println("异常信息=" + e.getMessage());
        } 
        System.out.println("程序继续...");
       

2. 如果异常没有发生，则顺序执行try的代码块，不会进入到catch

        try {
            String str = "123";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
            System.out.println("异常信息=" + e.getMessage());
        } 
        System.out.println("程序继续...");

3. 如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码- finally

        try {
            String str = "str";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
            System.out.println("异常信息=" + e.getMessage());
        } finally {
            System.out.println("finally代码块被执行...");
        }

        System.out.println("程序继续...");

4.如果try代码块有可能有多个异常
5.可以使用多个catch 分别捕获不同的异常，相应处理
6.要求子类异常写在前面，父类异常写在后面

public class try02 {
    public static void main(String[] args) {
        //1.如果try代码块有可能有多个异常
        //2.可以使用多个catch 分别捕获不同的异常，相应处理
        //3.要求子类异常写在前面，父类异常写在后面
        try {
            Person person = new Person();
            person = null;
            System.out.println(person.getName());
            int n1 = 10;
            int n2 = 0;
            int r = n1 / n2;
            System.out.println(r);
        } catch (NullPointerException e) {
            System.out.println("空指针异常" + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("算术异常" + e.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } 
    }
}

class Person {
    private String name = "jack";

    public String getName() {
        return name;
    }
}

都被Exception异常捕获掉了，后面子类异常自然也捕获不到异常了

7.可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，
因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，
都必须执行某个业务逻辑

        try {
            int n1 = 10;
            int n2 = 0;
            System.out.println(n1 / n2);
        } finally {
            System.out.println("finally...");
        }
        System.out.println("退出了程序");

出现异常后进入到finally直接退出程序，没有打印最后的信息
这里相当于main方法没有处理异常，直接throws给了JVM，JVM直接打印异常信息

练习

键盘输入，必须输入整数，否则无限循环

        Scanner scanner = new Scanner(System.in);
        int i = 0;
        while (true) {
            System.out.println("请输入：");
            String str = scanner.next();
            // 可能发生异常的代码
            try {
                i = Integer.parseInt(str);
                break;
            } catch (Exception e) {
                System.out.println("请输入一个整数!");
            }
        }
        System.out.println(i);

小结

2.2 throws

public class Throws01 {
    public static void main(String[] args) {

    }

    public void f2() throws FileNotFoundException,NullPointerException,ArithmeticException {
        //创建了一个文件流对象
        //1. 这里的异常是一个FileNotFoundException 编译异常
        //2. 使用前面讲过的 try-catch-finally
        //3. 使用throws ,抛出异常, 让调用f2方法的调用者(方法)处理
        //4. throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类
        //5. throws 关键字后也可以是 异常列表, 即可以抛出多个异常
        FileInputStream fis = new FileInputStream("d://aa.txt");

    }
}

public class ThrowsDetail {
    public static void main(String[] args)  /*throws ArithmeticException*/{
        f2();
    }
}

    public static void f2() /*throws ArithmeticException*/ {
        //1.对于编译异常，程序中必须处理，比如 try-catch 或者 throws
        //2.对于运行时异常，程序中如果没有处理，默认就是throws的方式处理

        int n1 = 10;
        int n2 = 0;
        double res = n1 / n2;
    }

编译时异常


这里f1()调用f3()方法，f3是编译型异常，必须由程序员显式的处理，否则会报错

运行时异常

2.3 throw(自定义异常)

public class CustomException01 {
    public static void main(String[] args) /*throws AgeException*/{

        int age = 100;
        if (!(age>=60 && age<=180)){
            throw new AgeException("年龄错误");
        }
        System.out.println(age);
    }
}

class AgeException extends RuntimeException{
    public AgeException(String message) {
        super(message);
    }
}

// 如果时Exception(编译时异常)，就要显式的处理，很不方便
//class AgeException extends Exception{
//    public AgeException(String message) {
//        super(message);
//    }
//}

throw和throws的区别

Exercise