文章目录
异常概述
异常的概念
异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是:
- 异常:指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中,异常本身是一个类, 产生异常就是创建异常对象并抛出了一个异常对象。Java处
理异常的方式是中断处理。
异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件,根本不能运行.
-
用户输入了无效数据。
-
找不到需要打开的文件。
-
在通信过程中丢失了网络连接，或者JVM内存不足。
异常的体系
所有异常类都是java.lang.Exception类的子类型。 Exception类是Throwable类的子类。 除了Exception类之外，还有另一个名称为Error的子类，它派生自Throwable类。
错误是在严重故障的情况下发生的异常情况，Java程序不处理这些情况。 生成错误以指示运行时环境生成的错误。例如：JVM内存不足。 通常，程序无法从错误中恢复。
Exception类有两个主要的子类：IOException类和RuntimeException类。
异常的方法
以下是Throwable类中可用的方法列表。
| 编号 | 方法 | 异常 |
|---|---|---|
| 1 | public String getMessage() | 返回有关已发生的异常的详细消息，此消息在Throwable构造函数中初始化。 |
| 2 | public Throwable getCause() | 返回由Throwable对象表示的异常的原因。 |
| 3 | public String toString() | 返回与getMessage()结果连接的类名称。 |
| 4 | public void printStackTrace() | 将toString()的结果与堆栈跟踪一起打印到System.err(错误输出流)。 |
| 5 | public StackTraceElement [] getStackTrace() | 返回包含堆栈跟踪上每个元素的数组。 索引0处的元素表示调用堆栈的顶部，而数组中的最后一个元素表示调用堆栈底部的方法。 |
| 6 | public Throwable fillInStackTrace() | 使用当前堆栈跟踪填充此Throwable对象的堆栈跟踪，添加堆栈跟踪中的任何先前信息。 |
异常的产生过程解析
异常的处理
Java异常处理的五个关键字：try、catch、finally、throw、throws、
抛出异常 throw
在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。
在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？
-
创建一-个异常对象。封装一 些提示信息(信息可以自己编写)。
-
需要将这个异常对象告知给调用者。怎么告知呢?怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
使用格式：
throw new 异常类名(参数)
throw关键字的作用：
可以使用throw关键字在指定的方法中抛出指定异常
注意：
- throw关键字必须写在方法的内部
- throw关键字后面new的对象必须时Exception或者Exception的子类对象
- throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
- throw关键字后面创建的时RuntimeException或者时 RuntimeException的子类对象，我们可以不处理，默认交给JVM处理（打印异常、中断程序）
- throw关键字后面创建的时编译异常（写代码的时候报错）我们必须处理这个异常，要么throws，要么try…catch。
public static int getElement(int[] arr, int index){
// 如果数组arr是空null，那么我们就抛出空指针异常，告知方法调用者床底的数组是null
if(arr == null){
throw new NullPointerException("传递的数组的值是null");
}
// 如果index超出了arr数组的长度范围，那么我们就抛出数组索引越界异常，
if(index < 0 || index > arr.length - 1){
throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的范围");
}
return arr[index];
}
Objects非空判断
还记得我们学习过一-个类Objects吗，曾经提到过它由一些静态的实用方法组成，这些方法是null-save (空指针安
全的)或null-tolerant (容忍空指针的) , 那么在它的源码中，对对象为null的值进行了抛出异常操作。
- public static T requireNonNull(T obj) :查看指定引用对象不是null。
查看源码发现这里对为 null 的进行了抛出异常操作:
public static <T> T requireNonNull(T obj) {
if(obj == null)
throw new NullPointerExeception();
return obj;
}
所以我们判断某个对象是否为空时，可以直接调用Objects工具类的requireNonNull()方法即可。如：
public static void myMathod(Object obj){
Objects.requireNonNull(obj, "传递的对象是null"); // 第二个参数可以省略。
}
声明异常 throws
声明异常：将问题标识出来，报告给调用者。如果方法内通过 throw 抛出了编译时异常，而没有捕获处理(稍后讲解该方式) ，那么必须通过 throws 进行声明，让调用者去处理。
关键字 throws 运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)。
声明异常格式：
修饰符 返回值类型 方法名(参数) throws 异常类名1, 异常类…{ }
注意：
-
throws关键字必须写在方法声明处
-
throws关键字后边声明的异常必须是Exception或者Exception的子类
-
方法内部如果抛出多个异常，那么throws后面必须也
如果抛出的多个异常对象有子类关系，那么直接声明父类异常即可
-
调用一个声明抛出异常的方法，我们就必须要处理声明的异常
- 处理方法1：要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
- 处理方法2：要么try…catch自己处理异常。
处理方法1：声明异常的代码演示: (main和readFile方法声明时，都带有throws FileNotFoundException)
public static void main(String[] args) throws FileNotFoundException, IOException {
readFile("c:\\a.txt");
}
/*
定义一个方法，对传递的文件路径进行合法性判读
如果路径不是“c:\\a.txt”，那么我们就抛出文件找不到异常对象，告知方法的调用者
注意：
FileNotFoundException是编译异常，跑出来编译异常，就必须处理这个异常
可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法调用者处理
*/
public static void readFile(String filePath) throws FileNotFoundException{
if(!filePath.equals("c:\\\\a.txt")){
throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
}
// 如果传递的路径不是.txt结尾的，那么我们就抛出IO异常对象，告知方法调用者，文件后缀名不对
if(filePath.endWith(".txt")){
throw new IOException("文件后缀名不对！");
}
}
捕获异常 try…catch
在方法中可使用try和catch关键字的组合捕获异常。try/catch块放在可能生成异常的代码周围。try/catch块中的代码称为受保护代码，使用try/catch的语法如下所示 -
语法
try {
// Protected code
} catch (ExceptionName e1) {
// Catch block
}
Java
将容易出现异常的代码放在try块中。 发生异常时，异常由与其关联的catch块处理。 每个try块都应该紧跟一个catch块或者一个块finally。
catch语句涉及声明尝试捕获的异常类型。 如果受保护代码中发生异常，则会检查try之后的catch块(或多个块)。如果发生的异常类型列在catch块中，则异常将传递给catch块，就像将参数传递给方法参数一样。
示例
以下是使用2个元素声明的数组，然后尝试访问引发异常的数组的第3个元素。
// 文件 : ExcepTest.java
import java.io.*;
public class ExcepTest {
public static void main(String args[]) {
try {
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}
Java
执行上面示例代码，得到以下结果：
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block
如何获取异常信息：
Throwable类中定义了一些查看方法：
-
public String getMessage()：获取异常的描述信息，原因（提示给用户的时候，就提示错误原因）
-
public String toString()：获取异常的类型和异常描述信息
-
public void printStackTrace()：打印异常的跟踪栈信息并输出到控制台，默认调用此方法，打印的异常信息时最全面的
包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都是使用printStackTrace。
finally 代码块
finally：由于异常会引发程序跳转，导致一些语句执行不到，而finally关键字就是解决这个问题，有一些代码无论如何异常发生与否都要执行，在finally代码块中存放的代码都是一定会被执行的。
finally不能单独使用，必须和try一块使用，在try块或catch块之后。无论受保护的代码块是否发生异常，最终都会执行finally块中的代码。
使用finally块运行要执行的任何清理类型语句，无论受保护代码中发生什么。
finally块放置在catch块的末尾，它的语法语法如下 -
try {
// Protected code
} catch (ExceptionType1 e1) {
// Catch block
} catch (ExceptionType2 e2) {
// Catch block
} catch (ExceptionType3 e3) {
// Catch block
}finally {
// The finally block always executes.
}
示例：
public class ExcepTest {
public static void main(String args[]) {
int a[] = new int[2];
try {
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) { // 捕获数组索引越界异常
System.out.println("Exception thrown :" + e);
}finally {
a[0] = 6;
System.out.println("First element value: " + a[0]);
System.out.println("The finally statement is executed");
}
}
}
异常注意事项
一个try 多个catch注意事项：
-
catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上面，否则会报错
如：ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
-
运行时异常被抛出，可以不处理，即不捕获也不声明抛出
-
如果finally有return语句，永远返回finally中的结果，避免该情况.
-
如果父类抛出了多个异常，子类覆盖父类方法时，只能抛出相同的异常或者是他的子集。
-
父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理,不能
声明抛出 -
在try/catch后可以追加 finally 代码块，其中的代码一定会被执行，通常用于资源回收。
自定义异常
可以在Java中创建自己的异常。 在编写自己的异常类时，请注意以下几点 -
- 所有异常必须是
Throwable的子类。 - 如果要编写由处理或声明规则自动强制执行的已检查异常，则需要扩展
Exception类。 - 如果要编写运行时异常，则需要扩展
RuntimeException类。
可以定义自己的Exception类，如下所示 -
class MyException extends Exception {
}
只需要扩展预定义的Exception类来创建自己的Exception类。 这些都是经过检查的异常。 以下InsufficientFundsException类是一个用户定义的异常，它扩展了Exception类，使其成为一个已检查的异常。异常类与任何其他类一样，包含有用的字段和方法。
示例
// 文件：InsufficientFundsException.java
import java.io.*;
public class InsufficientFundsException extends Exception {
private double amount;
public InsufficientFundsException(double amount) {
this.amount = amount;
}
public double getAmount() {
return amount;
}
}
为了演示如何使用用户定义的异常，以下CheckingAccount类的withdraw()方法中包含抛出InsufficientFundsException。
// 文件名称：CheckingAccount.java
import java.io.*;
public class CheckingAccount {
private double balance;
private int number;
public CheckingAccount(int number) {
this.number = number;
}
public void deposit(double amount) {
balance += amount;
}
public void withdraw(double amount) throws InsufficientFundsException {
if(amount <= balance) {
balance -= amount;
}else {
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
public double getBalance() {
return balance;
}
public int getNumber() {
return number;
}
}
以下BankDemo程序演示了如何调用CheckingAccount类的deposit()和withdraw()方法.
// 文件： BankDemo.java
public class BankDemo {
public static void main(String [] args) {
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositing $500...");
c.deposit(500.00);
try {
System.out.println("\nWithdrawing $100...");
c.withdraw(100.00);
System.out.println("\nWithdrawing $600...");
c.withdraw(600.00);
} catch (InsufficientFundsException e) {
System.out.println("Sorry, but you are short $" + e.getAmount());
e.printStackTrace();
}
}
}
执行上面示例代码，得到以下结果 -
Depositing $500...
Withdrawing $100...
Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
at CheckingAccount.withdraw(CheckingAccount.java:25)
at BankDemo.main(BankDemo.java:13)
扫一扫
586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
