Java 学习笔记：第六章异常机制

最新推荐文章于 2021-07-13 16:41:23 发布

人在囧途^o^

最新推荐文章于 2021-07-13 16:41:23 发布

阅读量332

点赞数

分类专栏： Java 文章标签： Java

本文链接：https://blog.csdn.net/weixin_44626569/article/details/89281566

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Java 学习笔记：第六章异常机制

6.1 导引问题
6.2 异常（Exception）的概念
6.3 异常分类
6.3.1 Error
6.3.2 Exception
6.3.3 RuntimeException 运行时异常
6.3.4 CheckedException 已检查异常
6.4 异常的处理方式之一：捕获异常
6.5 异常的处理方式之二：声明异常（throw 子句）
6.6 自定义异常
6.7 如何利用百度解决异常问题
总结

6.1 导引问题

在实际工作中，我们遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求；你的程序要打开某个文件，这个文件可能不存在或者文件格式不对；你要读取数据库的数据，数据可能是空的；我们的程序在运行着，但是内存或硬盘满了等等。

软件程序在运行过程中，诶城都可能遇到这些例外的情况，或者叫异常，我们怎么让写的程序作出合理的处理，安全的退出，而不至于成怒向崩溃呢？我们本章就要讲解这些问题。

如果我们要拷贝一个文件，在没有异常机制的情况下，我们需要考虑克重异常情况，伪代码：

【示例6-1】伪代码使用 if 处理程序中可能出现的各种情况

public class Test1 {
    public static void main(String[] args) {
        //将d:/a.txt复制到e:/a.txt
        if("d:/a.txt"这个文件存在){
            if(e盘的空间大于a.txt文件长度){
                if(文件复制一半IO流断掉){
                    停止copy，输出：IO流出问题！
                }else{
                    copyFile("d:/a.txt","e:/a.txt");
                }
            }else{
                System.out.println("e盘空间不够存放a.txt！");
            }
        }else{
            System.out.println("a.txt不存在！");
        }
    }
}

这种方式，有连个坏处：

逻辑代码和错误处理代码放在一起！
程序员的本身需要考虑的例外情况复杂，对程序员本身要求较高！

那么，我们如何解决应对异常情况呢？Java 的异常机制给我们提供了方便的处理方式。如上情况，如果是用 Java 的异常机制来处理，示意代码如下：

try {
    copyFile("d:/a.txt","e:/a.txt");
} catch (Exception e) {
    e.printStackTrace();
}

异常机制本质

就是当程序出现错误，程序安全退出的机制。

6.2 异常（Exception）的概念

异常指程序运行过程中出现的非正常现象，例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。

在Java 的异常处理机制中，引进了很多用来描述和处理异常的类，称为异常类。异常类定义了包含了该类异常的信息和异常进行处理的方法。

所谓异常处理，就是指程序在出现问题时依然可以正确执行完。

我们开始看我们的第一个异常对象，并分析一下异常机制是如何工作的。

【示例6-2】异常的分析

public class Test2 {
    public static void main(String[] args) {
        int i=1/0;  //除数为0
        System.out.println(i);
    }
}

执行结果

在这里插入图片描述

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

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

6.3 异常分类

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

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

在这里插入图片描述

6.3.1 Error

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

Error 表明系统JVM 已经处于不可恢复的崩溃状态，我们不需要管它。

在这里插入图片描述

Error 与 Exception的区别

我开着车走在路上，一头猪冲在路中间，我刹车，这叫一个异常。
我开着车在路上，发动机坏了，我停车，这叫错误。系统处于不可恢复的崩溃状态。发动机什么时候坏？我们普通司机能管吗？不能。发动机什么时候坏是汽车厂发动机制造商的事。

6.3.2 Exception

Exception 是程序本身能够处理的异常，如：空指针异常（NullPointException）、数组下标越界异常（ArrayIndexOutOfBoundsException）、理性转换异常（ClassCastException）、算术异常（ArithmeticException）等。

Exception类是所有异常类的父类，其子类对应了各种各样可能出现的异常事件。通常Java 的异常可分为：

RuntimeException 运行时异常
CheckedException 已检查异常

6.3.3 RuntimeException 运行时异常

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

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

【示例6-3】 ArithmeticException 异常：试图除以0

public class Test3 {
    public static void main(String[] args) {
        int b=0;
        System.out.println(1/b);
    }
}

执行结果

在这里插入图片描述

解决如上异常需要修改代码：

public class Test3 {
    public static void main(String[] args) {
        int b=0;
        if(b!=0){
            System.out.println(1/b);
        }
    }
}

当程序访问一个空对象的成员变量或方法，或者访问一个空数组的成员时会发生空指针异常（NullPointerException）。怎么处理？

【示例6-4】 NullPointException 异常

public class Test4 {
public static void main(String[] args) {
String str=null;
System.out.println(str.charAt(0));
}
}

执行结果：

在这里插入图片描述
解决空指针异常，通常是增加非空判断：

public class Test4 {
    public static void main(String[] args) {
        String str=null;
        if(str!=null){
            System.out.println(str.charAt(0));
        }
    }
}

引用数据类型转换时，有可能发生类型转换异常（ClassCastException）

【示例6-5】ClassCastException 异常

class Animal{
     
}
class Dog extends Animal{
     
}
class Cat extends Animal{
     
}
public class Test5 {
    public static void main(String[] args) {
        Animal a=new Dog();
        Cat c=(Cat)a;
    }
}

执行结果：

在这里插入图片描述

解决 ClassCastException 的典型方式：

public class Test5 {
    public static void main(String[] args) {
        Animal a = new Dog();
        if (a instanceof Cat) {
            Cat c = (Cat) a;
        }
    }
}

当程序访问一个数组的某个元素的时候，如果这个元素的索引超出0~数组长度-1这个范围，则会出现数组下标越界异常（ArrayIndexOutOfBoundsException）。

【示例6-6】 ArrayIndexOutOfBoundsException 异常

public class Test6 {
    public static void main(String[] args) {
        int[] arr = new int[5];
        System.out.println(arr[5]);
    }
}

执行结果：

在这里插入图片描述
解决数组做阴越界异常的方式，增加关于边界的判断：

public class Test6 {
    public static void main(String[] args) {
        int[] arr = new int[5];
        int a = 5;
        if (a < arr.length) {
            System.out.println(arr[a]);
        }
    }
}

在使用包装类将字符串转换成基本数据类型时，如果字符串的格式不正确，则会出现数字格式异常（NumberFormatException）。

【示例6-7】 NumberFromatException 异常

public class Test7 {
    public static void main(String[] args) {
        String str = "1234abcf";
        System.out.println(Integer.parseInt(str));
    }
}

执行结果：

在这里插入图片描述

数字格式化异常的解决，可以引入正则表达式来判断是否为数字：


import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class Test7 {
    public static void main(String[] args) {
        String str = "1234abcf";
        Pattern p = Pattern.compile("^\\d+$");
        Matcher m = p.matcher(str);
        if (m.matches()) { // 如果str匹配代表数字的正则表达式,才会转换
            System.out.println(Integer.parseInt(str));
        }
    }
}

注意事项

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

6.3.4 CheckedException 已检查异常

所有不是 RuntimeException 的异常，统称为 Checked Exception，又被称为 “已检查异常”，如 IOException、SQLException 等以及用户自定义的Exception 异常。这类异常在编译时就必须做出处理，否则无法通过编译：

在这里插入图片描述
如图所示，异常的处理方式有两种：使用“try/catch”捕获异常、使用 “throws”声明异常。

6.4 异常的处理方式之一：捕获异常

捕获异常是通过3个关键词来实现的：try-catch-finally。用try 来执行一段程序，如果出现异常，系统跑出了一个异常，可以通过它的类型来捕获（catch）并处理它，最后一步是通过 finally 语句为异常处理提供一个统一的出口，finally 所指定的代码都要被执行（catch语句可有多条；finally 语句最多只能有一条，根据自己的需要可有可无）：

在这里插入图片描述

上面过程详细解析：

1. try：

try 语句指定了一段代码，该代码就是异常捕获并处理的范围。在执行过程中，当任意一条语句产生异常时，就会跳过该条语句中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象，它后面的catch 语句分别对这些异常做相应的处理。

一个try 语句必须有至少一个catch 语句或一个finally 语句块

注意事项

当异常处理的代码执行结束后，不会回到try语句去执行尚未执行的代码。

2. catch：

每个try 语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型个的异常对象。

常用方法，这些方法均继承自 Throwable 类。

toString（）方法，显示异常的类名和产生异常的原因

getMessage（）方法，只显示产生异常的原因，但不显示类名。

printStackTrace（）方法，用来跟踪异常事件发生时堆栈的内容。

catch 捕获异常时的捕获顺序：

如果异常类之间有继承关系，在顺序安排上需注意。越是顶层的类，越放在下面，在不然就直接把多余的catch省略掉，也就是先捕获子类异常在捕获父类异常。

3. finally：

有些语句，不管是否发生了异常，都必须要执行，那么就可以把这样的语句放到 finally 语句块中。

通常在 finally 中关闭程序块已打开的资源，比如：关闭文件流、释放数据库连接等。

try-catch-finally 语句块的执行过程：

try-catch-finally 程序块的执行流程以及执行结果比较复杂。

基本执行过程如下：

程序首先执行可能发生异常的try 语句块。如果 try 语句没有出现异常则执行完后跳至 finally 语句块执行；如果 try 语句出现异常，则终端执行并根据发生的异常类型跳至相应的catch语句执行处理。catch语句块可以有多个，分别捕获不同类型的异常。catch 语句块执行完后程序会继续执行 finally 语句块。finally 语句是可选的，如果有的话，则不管是否发生异常，finally 语句都会被执行。

注意事项

即使try 和catch块中存在 return 语句，finally语句也会执行。是在执行完 finally 语句后再通过return 退出。
finally 语句块只有一种情况时不会执行的，那就是在执行finally 之前遇到了 System.exit（0）

【示例6-8】典型代码

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Test8 {
    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();
            }
        }
    }
}

6.5 异常的处理方式之二：声明异常（throw 子句）

当 CheckedException 产生时，不一定立刻处理它，可以再把异常 throws 出去。

在方法中使用 try-catch-finally 是由这个方法来处理异常。但是在一些情况下，当前方法并不需要处理发生的异常，而是向上传递给调用它的方法处理。

如果一个方法中可能产生某种异常，但是并不能确定如何出炉这种异常，则应根据异常规范在方法的首部声明该方法可能抛出的异常。

如果一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常，之间以逗号隔开。

【示例6-9】典型代码

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
public class Test9 {
    public static void main(String[] args) {
        try {
            readFile("joke.txt");
        } catch (FileNotFoundException e) {
            System.out.println("所需文件不存在！");
        } catch (IOException e) {
            System.out.println("文件读写错误！");
        }
    }  
    public static void readFile(String fileName) throws FileNotFoundException,          
    IOException {
        FileReader in = new FileReader(fileName);
        int tem = 0;
        try {
            tem = in.read();
            while (tem != -1) {
                System.out.print((char) tem);
                tem = in.read();
            }
        } finally {
            in.close();
        }
    }
}

注意事项

方法重写中声明异常原则：子类重写父类方法时，如果父类方法有声明异常，那么子类声明的异常范围不能超过父类声明的范围。

6.6 自定义异常

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

【示例6-10】自定义异常类

/**IllegalAgeException：非法年龄异常，继承Exception类*/
class IllegalAgeException extends Exception {
    //默认构造器
    public IllegalAgeException() {
     
    }
    //带有详细信息的构造器，信息存储在message中
    public IllegalAgeException(String message) {
        super(message);
    }
}

【示例6-11】自定义异常类的使用

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;
    }
}
 
public class TestMyException {
    public static void main(String[] args) {
        Person p = new Person();
        try {
            p.setName("Lincoln");
            p.setAge(-1);
        } catch (IllegalAgeException e) {
            e.printStackTrace();
            System.exit(-1);
        }
        System.out.println(p);
    }
}

在这里插入图片描述

使用异常机制的建议

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

6.7 如何利用百度解决异常问题

正常学习和开发中，我们疆场会遇到各种异常。大家在遇到异常时，需要遵循下面四步来解决：

细心查看异常信息，确定异常种类和相关Java 代码行号；
拷贝异常信息到百度，查看相关帖子，寻找解决思路；
前两步无法搞定，再问同学或同事；
前三步无法搞定，请示领导；

很多同学碰到异常一下就慌了，立刻开始请教别人搬救兵，殊不知这样做有两大坏处。第一，太不尊重别人，把别人当苦力。第二、失去提高自我的机会，自己解决一个异常，就意味着有能力解决一类异常。解决一类异常能大大提高自身能力。

总结

Error 与 Exception 都集成自 Throwable 类
Error 类层次描述了Java 运行时西永内部错误和资源耗尽错误。
Exception 类是所有异常类的父类，妻子类对应了各种各样可能出现的异常事件。
常见的异常类型

–ArithmeticException

–NullPointerException

–ClassCastException

–ArrayIndexOutOfBoundsException

–NumberFormatException
方法重写中声明异常原则：子类声明的异常范围不能超过父类声明的范围
异常处理的三种方式

–捕获异常:try-catch-finally

–声明异常:throws
自定义异常类只需从 Exception 类或者它的子类派生一个子类即可。

人在囧途^o^

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java 学习笔记：第六章异常机制

Java 学习笔记：第六章异常机制6.1 导引问题6.2 异常（Exception）的概念6.3 异常分类6.3.1 Error6.3.2 Exception6.3.3 RuntimeException 运行时异常6.3.4 CheckedException 已检查异常6.4 异常的处理方式之一：捕获异常6.5 异常的处理方式之二：声明异常（throw 子句）6.6 自定义异常6.7 如何利用百...
复制链接

扫一扫