异常处理
指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止。在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建并抛出了一个异常对象。Java处理异常的方式是中断处理。
异常体系
异常机制其实是帮助我们找到程序中的问题,异常的根类是Throwable,其下有两个子类:Error类与Exception类,平常所说的异常指Exception
异常体系的特点
异常体系中的所有类及其子类对象都具备可抛性。也就是说可以被throw和throws关键字所操作。
异常的分类
我们平常说的异常就是指Exception,因为这类异常一旦出现,我们就要对代码进行更正,修复程序。还有另外一种异常叫做运行时异常RuntimeException.
异常的产生过程解析
先运行下面的程序,程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。
class ArrayTools {
//对给定的数组通过给定的角标获取元素。
public static int getElement(int[] arr, int index) {
int element = arr[index];
return element;
}
}
public class ExceptionDemo {
public static void main(String[] args) {
int[] arr = {34, 12, 67};
intnum = ArrayTools.getElement(arr, 4);
System.out.println("num="+num);
System.out.println("over");
}
}
上述程序执行过程图解:
异常的处理
Java异常处理的五个关键字:try、catch、finally、throw、throws
基本格式:
try {
可能出现异常的代码;
} catch(异常对象) {
异常处理代码;
} finally {
释放资源;
}
变形格式:
- try…catch
- try…catch…catch…
- try…catch…catch…finally
①多个异常同时被捕获的时候,记住一个原则:先逮小后逮大
②通过在函数上声明,那么函数本身就不用解决,而由调用者解决,解决方式有两种:要么try…catch,要么抛。
③finally代码块:无论程序中是否有异常发生,并且无论try和catch是否顺利执行完毕,都会执行finally语句。
以下4中情况finally块不会被执行(面试题):
- 在finally语句中发生了异常
- 在前面的代码中使用了System.exit(0);
- 程序所在的线程全部死亡
- 关闭CPU
异常处理的常见方法操作:
String toString():获取异常名称
String getMessage():获取异常信息
void printStackTrace():获取异常类名和异常信息
代码演示
public class ThrowDemo {
public static void main(String[] args) {
int[] arr = {2, 4, 52, 2}; //创建一个数组
int index = 4; //根据索引找对应的元素
int element = getElement(arr, index);
System.out.println(element);
System.out.println("over");
}
public static int getElement(int[] arr,int index){
//判断索引是否越界
if(index < 0 || index > arr.length-1){
throw new ArrayIndexOutOfBoundsException("哥们,角标越界了~~~");
}
int element = arr[index];
return element;
}
}
注意:如果产生了问题,我们就会throw将问题描述类即异常进行抛出,也就是将问题返回给该方法的调用者。那么对于调用者来说,该怎么处理呢?一种是进行捕获处理,另一种就是继续讲问题声明出去,使用throws声明处理。
常见的异常类
异常名称 | 中文 |
---|---|
ClassCastException | 类型转换异常 |
ClassNotFoundException | 未找到相应类异常 |
ArithmeticException | 算术异常 |
ArrayIndexOutOfBoundsException | 数组下标越界异常 |
ArrayStoreException | 数组中包含不兼容的值抛出的异常 |
SQLException | 操作数据库异常 |
NullPointerException | 空指针异常 |
NoSuchFieldException | 字段未找到异常 |
NoSuchMethodException | 方法未找到异常 |
NumberFormatException | 字符串转换为数字抛出的异常 |
StringOutOfBoundsException | 字符串索引越界异常 |
IOException | 输入输出异常 |
IllegalAccessException | 不允许访问某类异常 |
InstantistionException | 指定类无法被实例化异常 |
FileNotFoundException | 文件未找到异常 |
对多异常的处理
①声明异常时,建议声明更具体的异常,这样处理更为具体。
②声明几个异常就相应有几个catch块。不要定义多余的catch块。如果多个catch块出现继承关系,那么父类的catch块放在最下面(先逮小后逮大)。
在进行catch处理时,catch中一定要有具体的处理方式。不要简单的定义一句e.printStackTrace(),也不要简单的打印一句输出语句。
自定义异常
按照Java面向对象的思想,将程序中出现的特有问题进行封装。自定义异常类必须继承Exception或者RuntimeException.
class MyException extends Exception {
String name;
MyException(String name) {
this.name = name;
}
}
继承Exception的原因:
因为异常类和异常对象都被抛出,具有可抛性,这个可抛性是throwable体系的独有特点。只有这个体系的类和对象才能被throw和throws操作。所以要先成为throwable体系中的一员,才能被throw和throws操作,那么就要继承Exception类或者RuntimeException类。当函数内部出现了throw抛出异常对象,那么就必须要给出对应的处理动作。
①要么在函数内部进行try…catch处理。
②要么在函数上声明让调用者处理。
一般情况下,函数内出现异常,函数上需要声明。
需求:在本程序中,对于除数是-1,也是错误的无法运算的。那么就要对该问题进行描述。
class FuShuException extends Exception {
private String msg;
private int value;
FuShuException() {
super();
}
FuShuException(String msg,int value) {
super(msg);
this.value = value;
}
public int getValue() {
return value;
}
}
class Test {
public int method(int a,int b) throws FuShuException { //函数内抛出异常对象时,通过throws关键字需要在函数上声明
if(b < 0)
throw new FuShuException("by FuShu",b); //通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
public class MyException {
public static void main(String[] args) {
Test t = new Test();
try {
int x = t.method(4,-1);
}catch(FuShuException e) {
System.out.println(e.getMessage());
System.out.println("ErrorValue:"+e.getValue());
}
System.out.println("over");
}
}
throws和throw的区别?
①有throws的时候可以没有throw,有throw的时候,如果throw抛的异常是Exception体系,那么必须有throws在方法上声明。
②throws用于方法的声明上,其后跟的是异常类名,后面可以跟多个异常类名,之间用逗号隔开。throw用于方法体中,其后跟的是一个异常对象名。
运行时异常
在Exception中有一个特殊的子类异常–运行时异常
特殊之处:
①如果在函数内抛出该异常,函数上可以不用声明,编译一样通过。
②如果函数上声明了该异常,调用者可以不进行处理,编译一样通过。
之所以不用在函数上声明,是不需要调用者处理。当RuntimeException异常发生时,希望程序停止,因为在运行时出现了无法运算的情况,希望停止程序后对代码进行修正。
常见的RuntimeExceprion异常:
异常名称 | 中文 |
---|---|
NullPointerException | 空指针异常 |
ArrayIndexOutOfBoundsException | 数组下标越界异常 |
ArithmeticException | 算术异常 |
ArrayStoreException | 数组中包含不兼容的值抛出的异常 |
IllegalArgumentException | 非法参数异常 |
SecurityException | 安全性异常 |
异常在子父类覆盖中的体现
①子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法只能抛出父类的异常和该异常的子类。
②如果父类方法在抛出多个异常,那么子类在覆盖该方法时,只能抛出该异常的子类。
③如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。如果子类方法发生了异常,只能对其进行try…catch处理,绝对不能抛。
异常练习:有一个长方形和圆形,都可以获取面积,对于面积出现非法的数值,视为获取面积出现的异常。问题通过异常来描述
import java.util.Scanner;
public class RunTimeExceptionTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入长方形的长和宽:");
int length = sc.nextInt();
int width = sc.nextInt();
Rectangle r = new Rectangle(length, width);
try {
int area = r.getArea();
System.out.println("长方形的面积:"+area);
}catch (NoValueException e) {
System.out.println(e.getMessage());
}
System.out.println("请输入圆的半径:");
int radius = sc.nextInt();
Circle c = new Circle(radius);
try {
int area = c.getArea();
System.out.println("圆的面积:"+area);
}catch (NoValueException e) {
System.out.println(e.getMessage());
}
}
}
interface Shape {
public int getArea();
}
class NoValueException extends RuntimeException {
private String msg;
NoValueException(String msg) {
this.msg = msg;
}
public String getMessage() {
return msg;
}
}
class Rectangle implements Shape {
private int length;
private int width;
private int area;
Rectangle(int length, int width) {
this.length = length;
this.width = width;
}
public int getArea() throws NoValueException {
if(length <= 0 || width <= 0) {
throw new NoValueException("长或宽出现零或负数,程序停止");
}
area = length * width;
return area;
}
}
class Circle implements Shape {
private int radius;
private static final int PI = 3;
private int area;
Circle(int radius) {
this.radius = radius;
}
public int getArea() throws NoValueException{
if(radius <= 0) {
throw new NoValueException("半径出现零或负数,程序停止");
}
area = PI * radius * radius;
return area;
}
}