Java异常_java unchecked exception有哪些

Exceptions

一、异常的概念

​ 在理想的世界里，用户输入数据的格式永远都是正确的，选择打开的文件也一定都存在，代码永远也不会出现Bug。然而，在显示世界中却充满了不良的数据和有问题的代码，这就是Java中的“异常”。

​ 异常的对象都派生于Throwable类的一个类实例，可分为Exception和Error两大部分，如下图所示：

二、异常的举例和异常的处理

2.1 异常的举例

• 非检查型异常(UncheckedException)

public class ExceptionsDemo {
    public static void main(String[] args) {
        sayHello(null);
    }

    /**
     * 运行时异常，非检查型异常。
     */

    public static void sayHello(String name) {

        System.out.println(name.toUpperCase()+",HELLO!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 检查型异常(CheckedException)

 @Test
    public  void read(){
        try {
            FileReader reader=new FileReader("file.txt");
            System.out.println("File Open");
            //异常发生后，try异常后面的代码不运行。
        } catch (FileNotFoundException e){
            System.out.println(e.getMessage());
        }

    }
1
2
3
4
5
6
7
8
9
10
11

• 错误异常(Error)

/**
     * Error展示，无限递归一个函数
     * 导致堆栈溢出
     */
    @Test
    public void loop(){
        loop();
    }
1
2
3
4
5
6
7
8

2.2 异常处理

• 捕获异常(try-catch-finally)

  @Test
    public  void read(){
        Reader reader=null;
        try {
            reader=new FileReader("file.txt");
            System.out.println("File Open");
            reader.read();
        } catch (FileNotFoundException e){
            System.out.println(e.getMessage());
            /**
             * 捕获多个异常时，需要注意异常的捕获顺序，
             * 大的异常放在后面,这里是多态的体现，如果将
             * IOException放在前面，它的子类FileNotFoundException
             * 也将捕获，后面的捕获操作将失效。
             */
        }catch (IOException e) {
            System.out.println(e.getMessage());
        }finally {
            try {
                if(reader!=null){
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
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

当有多个异常进行捕获时，异常类存在子父类关系，父类异常放在后面捕获。异常捕获后，try后面的代码不执行，但会执行finally中的代码，这部分代码不论前面的异常发生与否，都将执行。通常用于显示关闭连接资源，比如数据库连接等。

• 抛出异常(throw-throws)

public class Account {
    private float balance;
    /**
     *异常处理方法之抛出非法参数异常
     * @param value
     */
    public  void deposit(float value){
        if(value<0)
            throw new IllegalArgumentException();
    }
}
 @Test
    public  void show()  {
        Account account = new Account();
        account.deposit(-2);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
     * 抛出IO异常，必须处理，在方法声明出throws异常
     * @param value
     * @throws IOException
     */
    public void withdraw(float value) throws IOException {
        if(value<0)
            throw new IOException();
    }
 @Test
    public  void show() throws IOException {
        Account account = new Account();
        account.withdraw(-2);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.3 自定义异常

• 创建异常类

/**自定义异常类
 * @author tqwstart
 * @creat 2022-07-29 15:30
 */

public class InsufficientFundsException extends Exception{
    /**
     * 定义异常类构造方法
     */
    public InsufficientFundsException(){
        super("Insufficient funds in your account.");
    }
    public InsufficientFundsException(String message){
        super(message);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 使用自定义异常类

/**
 * @author tqwstart
 * @creat 2022-07-29 15:08
 */
public class Account {
    private float balance;
    public void withdrawMoney(float value) throws InsufficientFundsException {
        if(value>balance)
            throw new InsufficientFundsException();
    }
}
1
2
3
4
5
6
7
8
9
10
11

• 测试

 @Test
    public  void show()  {
        Account account = new Account();
        try {
            account.withdrawMoney(2);
        } catch ( InsufficientFundsException e) {
            System.out.println(e.getMessage());
        }
    }
1
2
3
4
5
6
7
8
9

三、小结

• 学习了异常的概念与异常的分类；
• 举例了非检查型异常、检查型异常和错误异常；
• 学习了异常的处理方法，了解多重异常时的捕获；
• 学习了自定义异常并使用。