异常~~~

异常

异常体系

编译时异常和运行时异常的区别

Java中的异常被分为两大类：编译时异常和运行时异常，也别成为受检异常和非受检异常

所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常

• 编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译
• 运行时异常：无需显示处理，也可以和编译时异常一样处理

JVM的默认处理方案

如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理

• 把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
• 程序停止执行

异常处理（try…catch…和throws）

如果程序出现了问题，我们需要自己来处理，有两种方案：

• try…catch…

  • 格式

  try{
      可能出现异常的代码；
  }catch(异常类名 变量名){
      异常的处理代码；
  }
  1
  2
  3
  4
  5

  • 执行流程

  程序从try里面的代码开始执行

  出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统

  当Java运行时系统接收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理

  执行完毕之后，程序还可以继续往下执行

  • 代码

    public class ExceptionDemo01 {
        public static void main(String[] args) {
            System.out.println("开始");
            method();
            System.out.println("结束");
        }
    
        public static void method() {
            try {
                int[] arr = {1, 2, 3};
                System.out.println(arr[3]);
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("越界");
                e.printStackTrace();
            }
        }
    }
    /*      开始
            越界
            结束
            java.lang.ArrayIndexOutOfBoundsException:3
            at ExceptionDemo01.method(ExceptionDemo01.java:11)
            at ExceptionDemo01.main(ExceptionDemo01.java:4)*/
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23

• throws

  • 格式

    throws 异常类名;
    1

    注意：这个格式是跟在方法的括号后面的

  • 编译时异常必须要进行处理，两种处理方案：try…catch…或者throws，如果采用throws这种方案，将来谁调用谁处理

  • 运行时异常可以不处理，出现问题后，需要我们回来修改代码

  • throws仅仅只是抛出异常，不会继续向下执行，如果要处理异常，还是需要使用try…catch…

  • 代码

    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class ExceptionDemo02 {
        public static void main(String[] args) {
            System.out.println("开始");
            //method();
            /*开始
            Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
            at ExceptionDemo02.method(ExceptionDemo02.java:20)
            at ExceptionDemo02.main(ExceptionDemo02.java:7)*/
            try {
                method2();
            } catch (ParseException e) {
                e.printStackTrace();
            }
            /*开始
            Tue Jun 07 00:00:00 CST 2022
            结束*/
            System.out.println("结束");
        }
        //编译时异常
        public static void method2() throws ParseException {
            String s = "2022-6-7";
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date d = sdf.parse(s);
            System.out.println(d);
        }
        //运行时异常
        public static void method() throws ArrayIndexOutOfBoundsException{
                int[] arr = {1, 2, 3};
                System.out.println(arr[3]);
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35

Throwsable 的成员方法

public class ExceptionDemo03 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }

    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("越界");
            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();
        }
    }
}
        /*开始
        越界
        5
        java.lang.ArrayIndexOutOfBoundsException: 5
        结束
        java.lang.ArrayIndexOutOfBoundsException: 5
        at ExceptionDemo03.method(ExceptionDemo03.java:11)
        at ExceptionDemo03.main(ExceptionDemo03.java:4)*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

自定义异常

格式：

public class 异常类名 extends Exception{
    无参构造
    带参构造
}
1
2
3
4

代码

自定义异常

package 自定义;

public class ScoreException extends Exception{
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}
1
2
3
4
5
6
7
8
9
10

教师类

package 自定义;

public class Teacher {
    public void checkScore(int score) throws ScoreException {
        if (score < 0 || score > 100) {
            throw new ScoreException("你给的分数有误！");
        }else{
            System.out.println("分数正常");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

测试类

package 自定义;

import java.util.Scanner;

public class TeacherTest {
    public static void main(String[] args) throws ScoreException {
        Teacher teacher = new Teacher();

        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();
        try{
            teacher.checkScore(score);
        }catch (ScoreException e){
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

测试结果

101
自定义.ScoreException: 你给的分数有误！
	at 自定义.Teacher.checkScore(Teacher.java:6)
	at 自定义.TeacherTest.main(TeacherTest.java:12)
1
2
3
4

throws和throw的区别