文章目录
一、基本含义
1.1 异常(Exception)原因:
(1)用户输入了非法数据。
(2)要打开的文件不存在。
(3)网络通信时连接中断,或者JVM内存溢出。
1.2 种类
异常种类:非检查性(运行)异常和检查性异常
1.2.1 非检查性(运行)异常
系统会自动提示该种异常。
异常类型 | 含义 |
---|---|
ArithmeticException | 当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。 |
ArrayIndexOutOfBoundsException | 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。 |
ArrayStoreException | 试图将错误类型的对象存储到一个对象数组时抛出的异常。 |
ClassCastException | 当试图将对象强制转换为不是实例的子类时,抛出该异常。 |
IllegalArgumentException | 抛出的异常表明向方法传递了一个不合法或不正确的参数。 |
IllegalMonitorStateException | 抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。 |
IllegalStateException | 在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。 |
IllegalThreadStateException | 线程没有处于请求操作所要求的适当状态时抛出的异常。 |
IndexOutOfBoundsException | 指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。 |
NegativeArraySizeException | 如果应用程序试图创建大小为负的数组,则抛出该异常。 |
NullPointerException | 当应用程序试图在需要对象的地方使用 null 时,抛出该异常 |
NumberFormatException | 当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。 |
SecurityException | 由安全管理器抛出的异常,指示存在安全侵犯。 |
StringIndexOutOfBoundsException | 此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。 |
UnsupportedOperationException | 当不支持请求的操作时,抛出该异常。 |
(1)空指针异常示例(NullPointerException)
String str = null;
System.out.println(str.length()); // 异常。长度为空。
(2)数组下标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = {1,2,3};
for(int i = 0;i <= 3; i++){ // 异常。数组下标只能达到2。
System.out.println(arr[i]);
}
(3)类型转换异常(ClassCastException)
class Animal{
}
class Dog extends Animal{
}
class Cat extends Animal{
}
public class Test{
public static void main(String[] args){
Animal a1 = new Dog();
Animal a2 = new Cat();
Dog d1 = (Dog)a1;
Dog d2 = (Dog)a2; // 异常。不可把动物猫转化为狗。
}
}
(4)算术异常(ArithmeticException)
int num1 = 12;
int num2 = 0;
System.out.println(num1/num2); // 异常。被除数不能为零。
1.2.1 检查性异常
需要手动添加捕获该异常的语句。
异常类型 | 含义 |
---|---|
ClassNotFoundException | 应用程序试图加载类时,找不到相应的类,抛出该异常。 |
CloneNotSupportedException | 当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。 |
IllegalAccessException | 拒绝访问一个类的时候,抛出该异常。 |
InstantiationException | 当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。 |
InterruptedException | 一个线程被另一个线程中断,抛出该异常。 |
NoSuchFieldException | 请求的变量不存在 |
NoSuchMethodException | 请求的方法不存在 |
(1)连接SQL错误(SQLException)
(2)文件不存在(ClassNotFoundException)
二、 异常方法
2.1 getMessage()
public String getMessage()
返回异常的详细信息
2.2 getCause()
public Throwable getCause()
返回一个Throwable 对象代表异常原因。
2.3 toString()
public String toString()
使用getMessage()的结果返回类的串级名字。
2.4 printStackTrace()
public void printStackTrace()
打印toString()结果和栈层次到System.err,即错误输出流。
2.5 getStackTrace()
public StackTraceElement [] getStackTrace()
返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。
2.6 fillInStackTrace()
public Throwable fillInStackTrace()
用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。
三、捕获并处理异常
项目 | 含义 |
---|---|
放置位置 | try/catch 代码块放在异常可能发生的地方。 |
作用 | 保护try代码块中的代码。 |
运行机制 | 类似于switch…case。 |
多重捕获 | 直接在后面添加catch语句块。先子类后父类。即就近原则。 |
3.1 try…catch 捕获并处理异常
语法:
try{
// 可能发生异常的代码块。
}catch(异常类型1 异常名1){
// catch块。输出该种类型异常的提示信息。
}catch(异常类型2 异常名2){
// catch块。输出该种类型异常的提示信息。
}catch(异常类型3 异常名3){
// catch块。输出该种类型异常的提示信息。
}
语法示例:
import java.io.*;
public class ExcepTest{
public static void main(String args[]){
try{
// 这是可能出现异常的代码块
int[] a = new int[2];
// 数组越界了(类型:ArrayIndexOutOfBoundsException)。后面语句不执行了,直接跳到catch判断异常类型语句
System.out.println("输出数组a[3] :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
e.printStackTrace();
}catch(FileNotFoundException f){
f.printStackTrace();
}
System.out.println("此语句不在try/catch中,没有异常判断!");
}
}
3.2 try…catch…finally 捕获并处理异常
语法:
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码,一定会被执行。作用:可以运行清理类型等收尾善后性质的语句。
}
示例:
Scanner input = new Scanner(System.in);
try{
System.out.println("请输入第一个数:");
int num1 = input.nextInt();
System.out.println("请输入第二数:");
int num2 = input.nextInt();
System.out.println("两数之和为:" + (num1 + num2));
}catch(inputMismatchException i){ // 先子类,后父类。
i.printStackTrace();
}catch(ArithmeticException a){
a.printStackTrace();
}catch(Exception e){ // Exception 是所有异常的父类,所以要放在最后。
e.printStackTrace();
}finally{
System.out.println("计算两数之和的程序结束了!");
}
四、抛出并未处理异常
项目 | throw | throws |
---|---|---|
作用 | 将产生的异常抛出 | 声明将要抛出何种类型的异常 |
属性 | 动作 | 声明 |
位置 | 方法体中 | 参数列表之后,方法体之前。 |
使用场景:一个方法没有捕获到一个检查性异常时。
声明次数:一个方法可以声明抛出多个异常,多个异常之间用逗号隔开。
语法:
public void 方法名(参数列表) throws 异常列表{
// 调用会抛出异常的方法或者
}
public class Test{
public void divide(int num1,int num2) throws Exception{
if(num2 == 0){
throw new Exception("除数num2不能为零!");
}else{
System.out.println("num1 ÷ num2 = " + num1 / num2);
}
}
// 捕获并处理异常。
public void compute1(){
try{
divide(5,0);
}catch( Exception e){
System.out.println(e.getMessage());
}
}
// 把异常抛出。交给更上一层调用者。
public void compute2() throws Exception{
divide(5,0);
}
public static void main(String[] agrs){
Test t1 = new Test();
// 正常执行。
t1.compute1();
// 提示错误。在main方法签名后加throws Exception 即可。
t1.compute2();
}
}
六、自定义异常类
适用场景:系统没有提供该类型时的异常。
子类性:
(1)所有异常都必须是 Throwable 的子类。
(2)自定义检查性异常类时,则需要继承 IOException 类。
(3)自定义运行异常类时,则需要继承 RuntimeException 类。
(4)简写。直接继承Exception类。
语法:
public class MyException extends Exception{
}
public class MyRuntimeException extends RuntimeException{
}
示例:
自定义检查性异常类:
import java.io.*;
public class MyException extends Exception{
/**
* 取出钱多于余额时,返回存储余额
*
*/
private double amount; // amount = 输入数字 - 实际余额。
public MyException(double amount){
this.amount = amount;
}
public double getAmount(){
return amount;
}
}
银行账户类:
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 MyException{ // 自定义异常调用。
if(amount <= balance){
balance -= amount;
}else{
double needs = amount - balance;
throw new MyException(needs); // 创建异常对象,并抛出异常结果。
}
}
//方法:返回余额
public double getBalance(){
return balance;
}
//方法:返回卡号
public int getNumber(){
return number;
}
}
主函数入口类:
public class BankDemo{
public static void main(String [] args){
// 创建账户实例对象。
CheckingAccount c = new CheckingAccount(101);
System.out.println("存入500元");
// 调用方法:存入500元钱。
c.deposit(500.00);
// 可能出现异常处:取钱。
try{
System.out.println("开始取钱了,取出100元!");
// 调用方法:取钱
c.withdraw(100.00);
System.out.println("再次取出500元钱");
// 调用方法:取钱。
c.withdraw(500.00); // 出现异常:因为账户中没有500元了。
}catch(MyException e){
System.out.println("取钱超了" + e.getAmount());
// 打印出出现异常的原因。即异常信息。
e.printStackTrace();
}
}
}
七、异常链
步骤:
(1)把捕获的异常包装成一个新的异常。
(2)在新的异常中,添加对原始异常的引用。
(3)再把新异常抛出。
原理:一个异常的发生导致另一个异常的发生。像链条一样。
/**
* tes1(): 抛出"异常1"异常。
* test2(): 调用test1(),捕获"异常1",并且包装成运行时异常。继续抛出。
* main():调用test2(),尝试捕获test2()方法抛出的异常。
*/
public class ChainTest{
public static void main(String[] args){
ChainTest ct = new ChainTest();
try{
ct.test2();
}catch(Exception e){
e.printStackTrace();
}
}
//
public void test1(){
throw new DrunkException("喝酒别开车!");
}
//
public void test2(){
try{
// 调用test1()方法。
test1();
}catch(DrunkException d){ // 捕获异常。
// 包装成新的RuntimeException异常。
RuntimeException newRE = new RuntimeException("司机一滴酒,亲人两行泪!");
// 向前追溯原始(最初)异常。
newRE.initCause(d);
// 简写。RuntimeException newRE = new RuntimeException(d);
// 抛出包装后的异常。
throw newRE;
}
}
}
自定义喝酒异常类:
public class DrunkException extends Exception{
public DrunkException(){
}
public DrunkException(String str){
super(str);
}
}
八、总结
(1)处理RuntimeException异常时,优化代码 + try-catch捕捉处理。
(2)多重try-catch后加Exception处理可能遗漏的异常。
(3)尽量去处理异常,减少直接使用printStackTrace()打印输出。
(4)本级异常,本级处理。根据实际业务情况,灵活处理异常。
(5)尽量添加finally语句,去释放占用的资源。