Java异常

Java异常

什么是异常

异常：也就是意外情况，指程序运行中出现的不期而至的各种状况（文件找不到、网络连接失败非法参数等）
意外情况：用户的输入不符合程序要求、打开某个文件发现文件不存在或者文件格式不对、读取数据库数据结果数据为空、程序跑着结果硬盘满了、除数为0等等

异常分类

检查性异常

最具代表性
检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。
举例：打开一个不存在的文件
检查性异常在编译时不能被简单的忽略

运行时异常

运行时异常是可能被程序员避免的异常。
运行时异常可以在编译时被忽略（写代码的时候不报错，一运行就报错了）

错误ERROR（不是异常）

错误不是异常
错误是脱离程序员控制的问题
错误在代码中通常被忽略
举例：当栈溢出时，一个错误就发生了，这种错误在编译里检查不到

异常体系结构

异常类

Java把异常当初对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的超类
异常类分为两大类：错误ERROR和异常Exception

ERROR

ERROR类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
Java虚拟机运行错误：当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止
发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况

Exception

Exception分支中有一个重要的子类RuntimeException（运行时异常）
- ArrayIndexOutOfBoundsException（数组下标越界）
- NullPointerException（空指针异常）
- ArithmeticException（算术异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找不到类）
这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
上面的异常一般都是程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生

Error和Exception区别：

Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；
Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

捕获和抛出异常

异常处理的5个关键字：try、catch、finally、throw、throws
捕获和抛出的代码：
- try：监控区域，监控try里的代码是否异常
- catch：捕获异常
  - try{
    
    }catch(相应捕获的异常类型){
    
    发生异常后要执行的内容
    
    }
  - 当“相应捕获的异常类型”里写的级别够高的话，则捕获的异常也多。
    
    例如：因为Throwable包含Error和Exception异常，所以catch(Throwable)可以把Error和Exception异常都捕获到；
  - catch可以写多个，但要从小到大（从上往下写）去捕获
- finally：处理善后工作，无论程序是否异常，finally里的程序都会执行（finally可以没有）
快捷键：选中要检测的代码，然后Ctrl+Alt+T
结束程序：System.exit();（举例5）
直接打印错误：printStackTrace（举例4）

举例1：

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //try是监控区域
        //通过catch来捕获异常
        //当发生catch小括号里的异常的话（捕获），就执行catch大括号里的程序
        //无论程序是否异常，finally里的程序都会执行(finally可以没有)
        try {
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("程序出现异常，分母不能为0");
        }finally {
            System.out.println("无论程序是否异常，finally里的程序都会执行");
        }
    }
}
//输出：
程序出现异常，分母不能为0
无论程序是否异常，finally里的程序都会执行

举例2：

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //try是监控区域
        //通过catch来捕获异常
        //当发生catch小括号里的异常的话（捕获），就执行catch大括号里的程序（处理）
        //无论程序是否异常，finally里的程序都会执行
        //将最大的catch写在后面，因为捕获异常是从上往下的
        try {
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("程序出现异常，分母不能为0");
        }catch(Throwable e){
            System.out.println("程序没有出现分母不能为0的情况，但程序出现了其它异常");
        }finally{
            System.out.println("无论程序是否异常，finally里的程序都会执行");
        }
    }
}

举例3：

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //try是监控区域
        //通过catch来捕获异常
        //当发生catch小括号里的异常的话（捕获），就执行catch大括号里的程序（处理）
        //无论程序是否异常，finally里的程序都会执行
        //将最大的catch写在后面，因为捕获异常是从上往下的
        try {
            System.out.println(a/b);
        }catch (Exception e){
            System.out.println("Exception");
        }catch(Throwable e){
            System.out.println("程序没有出现分母不能为0的情况，但程序出现了其它异常");
        }finally{
            System.out.println("无论程序是否异常，finally里的程序都会执行");
        }
    }
}
//输出：
Exception
无论程序是否异常，finally里的程序都会执行

举例4：

public class Test2 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();//如果捕获到错误，则将错误打印出来
        } finally {
        }
    }
}
//输出：
java.lang.ArithmeticException: / by zero
	at com.exception.Test2.main(Test2.java:8)

举例5：

public class Test2 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            System.exit(1);//当捕获到异常时程序结束
        } finally {
        }
    }
}

主动抛出异常

通过throw主动抛出异常
主动抛出异常一般在方法中使用

举例：

public class Test3 {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        test3.abc(4,2);
        test3.abc(1,0);
        test3.abc(6,2);//前面抛出异常，后面就不再执行
    }
    public void abc(int a,int b){
        if(b==0){
            throw new ArithmeticException();//主动抛出异常
        }
        System.out.println(a/b);
    }
}
//输出：
2
Exception in thread "main" java.lang.ArithmeticException
	at com.exception.Test3.abc(Test3.java:12)
	at com.exception.Test3.main(Test3.java:7)

在方法上抛出异常

假设在方法中处理不了这个异常，则可以在方法上抛出异常

throws可以将异常往上面的catch上抛，让它去处理

public class Test3 {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        try {
            test3.abc(4,2);
            test3.abc(1,0);
            test3.abc(6,2);//前面抛出异常，后面就不再执行
        } catch (ArithmeticException e) {
            System.out.println("抛出异常");
        }
    }
    //通过throws将异常往catch上面抛
    public void abc(int a,int b) throws ArithmeticException{
        System.out.println(a/b);
    }
}
//输出：
2
抛出异常

自定义异常

由于Java内置的异常类已经描述了在编程时出现的大部分异常情况，所以用户自定义异常并不常用
用户自定义异常，要继承Exception类
自定义异常类的步骤：
1. 创建自定义异常类
2. 在方法中通过throw关键字抛出异常对象
3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
4. 在出现异常方法的调用者中捕获并处理异常

举例

自定义异常：

//自定义异常类，要继承Exception
public class MyException extends Exception{
    //传递数字>10；
    private int detail;
    //构造器
    public MyException(int a){
        this.detail = a;
    }
    //toString：异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

主函数：

public class Test {
    //可能会存在异常的方法
    static void test(int a)throws MyException{
        System.out.println("传递的参数为："+a);
        if (a>10){
            throw new MyException(a);//抛出
        }
        System.out.println("Ok");
    }

    public static void main(String[] args) {
        try {
            test(9);
            test(20);//小于10，会抛出异常
        } catch (MyException e) {
            System.out.println("抛出异常：");
            e.printStackTrace();
        }
    }
}
//输出：
传递的参数为：9
Ok
传递的参数为：20
抛出异常：
MyException{detail=20}
	at com.exception.demo01.Test.test(Test.java:8)
	at com.exception.demo01.Test.main(Test.java:16)

posted @ 2022-01-24 14:01 史小鹏阅读(38) 评论(0) 收藏举报

刷新页面返回顶部

史小鹏

Java异常

Java异常

什么是异常

异常分类

检查性异常

运行时异常

错误ERROR（不是异常）

异常体系结构

异常类

ERROR

Exception

Error和Exception区别：

捕获和抛出异常

主动抛出异常

在方法上抛出异常

自定义异常

公告