Java_异常

Posted 2021-01-10 张飘扬

处理异常过程

Java采用面向对象的方式来处理异常, 处理过程:

1.抛出异常: 在执行一个方法时, 如果发生异常, 则这个方法生成代表该异常的一个对象, 停止当前执行路径, 并把异常对象提交给JRE
2.捕获异常: JRE得到该异常后, 寻找相应的代码来处理该异常. JRE在方法的调用栈中查找, 从生成异常的方法开始回溯, 直到找到相应异常处理代码为止

异常分类

JDK中定义了很多异常类, 这些类对应了各种各样可能出现的异常事件, 所有异常对象都派生于Throwable类的一个实例. 如果内置异常类不能够满足需要, 还可以创建自己的异常类

Java对异常进行了分类, 不同类型的异常分别用不同的Java类表示, 所有异常类的根类为java.lang.Throwable, Throwalble下面右派生了两个子类: Error和Exception, Java异常类的层次结构

Error

Error是程序无法处理的错误, 表示运行应用程序中较严重问题. 大多数错误与代码编写者所执行操作无关, 而代表代码运行时JVM出现的问题. 例如Java虚拟机运行错误(Virtual Machine Error), 当JVM不再继续执行操作所需内存资源时, 将出现OutOfMemoryError, 这些异常发生时, JVM一般会选择线程终止

Erro表明系统JVM已经处于不可恢复的崩溃状态

Exception

Exception是程序本身能够处理的异常, 如: 空指针异常(NullPointerException), 数组下标越界异常(ArrayIndexOutOfBoundsException), 类型转换异常(ClassCastException), 算术异常(ArithmeticException)等,Exception是所有异常类的父类, 其子类对应了各种各样可能出现的异常事件, 通常Java异常可分为RuntimeException(运行时异常), CheckedException(已检查异常)

派生于RuntimeException的异常, 如被0除, 数组下标越界, 空指针等, 其产生比较频繁, 处理麻烦, 如果显式声明或捕获将会对程序可读性和运行效率影响很大, 因此系统自动检测并将它们交给缺省的异常处理程序(用户不必对其处理)

这类异常通常是由编程错误导致的, 所以在编写程序时, 并不要求必须使用异常处理机制来处理这类异常, 经常需要通过增加"逻辑处理来避免这些异常"

注意事项:

在方法抛出异常之后, 运行时系统将转为寻找合适的异常处理器(exception handler), 潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合. 当异常处理器所能处理的异常类型与方法抛出的异常类型相符时, 即为合适的异常处理器
运行时系统以发生异常的方法开始, 一次回查调用的方法, 直至找到含有合适异常的处理器的方法并执行. 当运行时系统遍历调用栈而未找到合适的异常处理器, 则运行时系统终止, 同时意思着Java程序的终止

/****************被0除异常***************/
public static void main(String[] args) {
    int b = 0;
    System.out.println(1/b);
}

/*
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at zyb.cn.TestException.main(TestException.java:6)
*/

/**************数组下标越界异常************/
public static void main(String[] args) {
    int[] arr = new int[5];
    System.out.println(arr[5]);
}

/*
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
    at zyb.cn.TestException.main(TestException.java:6)
*/

/******************类型转异常***************/
public static void main(String[] args) {
    Animal a = new Dog();
    Cat c = (Cat)a;
}
class Animal {  
}
class Dog extends Animal {  
}
class Cat extends Animal {  
}

/*
Exception in thread "main" java.lang.ClassCastException: zyb.cn.Dog cannot be cast to zyb.cn.Cat
    at zyb.cn.TestException.main(TestException.java:6)
*/

/******************数字格式异常*****************/
public static void main(String[] args) {
    String str = "12345abf";
    System.out.println(Integer.parseInt(str));
}

/*
Exception in thread "main" java.lang.NumberFormatException: For input string: "12345abf"
    at java.base/java.lang.NumberFormatException.forInputString(Unknown Source)
    at java.base/java.lang.Integer.parseInt(Unknown Source)
    at java.base/java.lang.Integer.parseInt(Unknown Source)
    at zyb.cn.TestException.main(TestException.java:6)
*/

所有不是RuntimeException的异常, 统称为CheckedException, 又被称为"已检查异常", 如IOException, SQLException等以及用自己定义的Exception异常. 这类异常在编译时就必须处理, 否则无法通过编译.

异常处理方法之一: 捕获异常

捕获异常通过3个关键字来实现: try--catch--finally. 用try来执行一段程序, 如果出现异常, 系统抛出一个异常, 可以通过他的类型来捕获, 并使用catch处理它, 最后一步是通过finally语句为异常处理提供一个统一的出口, finally所指定的代码块都要被执行(catch语句可能有多余, finally语句只能有一条, 根据自己需要可有可无)

详解:

try:
　　try语句指定了一段代码, 该段代码就是异常捕获并处理的范围. 在执行过程中, 当任意一条语句产生异常时, 就会跳过该语句中后面的代码. 代码中可能会产生并抛出一种或几种类型的异常对象, 它后面的catch语句分表对这些异常做相应的处理
　　一个try语句必须带有至少一个catch语句块或一个finally语句块
　　注意: 当异常的代码执行结束以后, 不会回到try语句去执行尚未执行的代码

catch:
　　每个try语句块可以伴有一个或多个catch语句, 用于处理可能产生的不同类型的异常对象
　　常用方法(这些方法均继承子Throwable类):
　　　　toString()显式异常的类名
　　　　getMessage()只显示产生异常的原因, 但不显示类名
　　　　printStackTrace()用来跟踪异常事件发生时堆中的内容
　　catch捕获异常时的顺序: 如果异常类之间有继承关系, 在顺序安排上需注意. 越是顶层的类, 越放在下面, 再不然就直接把多余的catch省略掉. 也就是先捕获子类异常在捕获父类异常

finally:
　　有些语句, 不管是否发生了异常, 都必须要执行, 那么就可以把这样的语句放到finally语句块中
　　通常在finally中关闭程序块中已打开的资源, 如: 关闭文件流, 释放数据库连接等

注意事项:
　　即使try和catch块中存在return语句, finally语句也会执行, 是在执行完finally语句后再通过return退出
　　finally语句块中只有一种情况是不会执行的, 那就是在执行finally之前遇到了System.exit(0)结束程序运行

/************经典代码***************/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public static void main(String[] args) {
    FileReader reader = null;
    try {
        reader = new FileReader("d:/a.txt");
        char c = (char) reader.read();
        char c2 = (char) reader.read();
        System.out.println("" + c + c2);
    }
    catch (FileNotFoundException e) {   // 子类异常在父类异常前面
        e.printStackTrace();
    }
    catch (IOException e) {
        e.printStackTrace();
    }
    finally {
        try {
            if(reader != null) {
                reader.close();
            }
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }
}

/*
java.io.FileNotFoundException: d:a.txt (系统找不到指定的文件。)
    at java.base/java.io.FileInputStream.open0(Native Method)
    at java.base/java.io.FileInputStream.open(Unknown Source)
    at java.base/java.io.FileInputStream.<init>(Unknown Source)
    at java.base/java.io.FileInputStream.<init>(Unknown Source)
    at java.base/java.io.FileReader.<init>(Unknown Source)
    at zyb.cn.TestException.main(TestException.java:12)
*/

异常处理方法之二: 声明异常(throws子句)

当CheckedException产生时, 不一定立刻处理它, 可以再把异常throws出去, 在方法中使用try--catch--finally是由这个方法来处理异常. 但在一些情况下, 当前方法并不需要处理发生的异常类, 而是向上传递给调用它的方法来处理
如果一个方法中可能产生某种异常, 但是并不能确定如何处理这种异常, 则应根据异常规范在方法首部声明该方法可能抛出的异常
如果一个方法抛出多个已检查异常, 就必须在方法的首部列出所有的异常, 之间用逗号隔开

/*****************实例程序***************/
import java.io.FileReader;
import java.io.IOException;

public static void main(String[] args) throws IOException {
    readMyFile();
}
public static void readMyFile() throws IOException {
    FileReader reader = null;
    reader = new FileReader("d:/a.txt");
    System.out.println("step1");
    char c1 = (char) reader.read();
    System.out.println(c1);
    
    if(reader != null) { 
        reader.close();
    }
}

自定义异常类

在程序设计中, 可能会遇到JDK提供的任何标准异常类都无法充分描述清楚想要表达的问题, 这种情况下可以创建自己的异常类, 即自定义异常类
自定义异常类需要从Exception类或它的子类派生一个子类即可
自定义异常类如果继续Exception类, 则为受检查异常, 必须对其进行处理, 如果不处理, 可以让自定义异的常类继承运行时异常RuntimeException类
习惯上, 自定义异常类应该包含两个构造器: 一个是默认构造器, 另一个是带有详细信息的构造器

/***********自定义异常示例*************/
class IllegalAgeException extends Exception {
    // 默认构造器
    public IllegalAgeException() {
        
    }   
    // 带有详细信息的构造器, 信息存储在message中
    public IllegalAgeException(String message) {
        super(message);
    }
}

/***********自定义异常的使用*************/
public static void main(String[] args) {
    Person p = new Person();
    try {
        p.setName("Alice");
        p.setAge(-1);
    }
    catch(IllegalAgeException e) {
        e.printStackTrace();
        System.exit(-1);
    }
    System.out.println(p);
}

class IllegalAgeException extends Exception {
    // 默认构造器
    public IllegalAgeException() {
        
    }   
    // 带有详细信息的构造器, 信息存储在message中
    public IllegalAgeException(String message) {
        super(message);
    }
}

class Person {
    private String name;
    private int age;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) throws IllegalAgeException {
        if(age < 0) {
            throw new IllegalAgeException("人的年龄不应该为负数");
        }
        this.age = age;
    }
    
    public String toString() {
        return "name is " + name + " and age is " + age;
    }
}

/*
zyb.cn.IllegalAgeException: 人的年龄不应该为负数
    at zyb.cn.Person.setAge(MyTestException.java:39)
    at zyb.cn.MyTestException.main(MyTestException.java:8)
*/

异常机制使用建议

1. 避免使用异常处理代替错误处理, 这样会降低程序的清晰性, 并且效率低下
   
2. 处理异常不可以代替简单测试, 只是在异常情况下使用异常机制
   
3. 不要进行小粒度的异常处理, 应该将整个任务包装在一个try语句中
   
4. 异常往往在高层处理