Java异常的处理（java异常处理适用于方法检查到一个错误）

1 JVM处理方式

JVM处理方式

将异常信息(异常类名，异常的原因，异常位置)打印在控制台

退出JVM，终止程序的运行

2 捕获异常try…catch

格式

try{

编写可能会出现异常的代码

}catch(异常类型 e){

处理异常的代码

//记录日志/打印异常信息/继续抛出异常

}

try：该代码块中编写可能产生异常的代码

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理

try和catch都不能单独使用,必须连用

示例

/**

单catch捕获处理异常的格式

try{

} catch(异常类名 变量名){

?

}

说明

try代码块

编写可能会出现异常的代码,如果该代码块中的某行代码出现了异常

则try代码块后续的代码不会被执行了

catch代码块：

编写处理异常的代码，如果try代码块中的代码没有出现异常

则catch代码块的代码不会被执行

*/

public class ExceptionDemo01 {
public static void main(String[] args){
int a = 0;
test(a);
}
private static void test(int a) {
try{
/*
1.创建一个对象：ArithmeticException ee = new ArithmeticException("/ by zero");
2.抛出异常对象：ee
*/
int result = 100 / a;
System.out.println("result = " + result);
}catch (ArithmeticException e){
System.out.println("到这里了吗");
// 在调式阶段，一般都会调用该方法打印异常信息
e.printStackTrace();
}
System.out.println("来这里");
}
}

多个异常使用捕获又该如何处理

多个异常分别处理

多个异常一次捕获，多次处理

多个异常一次捕获一次处理

一般我们是使用一次捕获多次处理方式

格式

try{

编写可能会出现异常的代码

}catch(异常类型A e){ 当try中出现A类型异常,就用该catch来捕获

处理异常的代码

//记录日志/打印异常信息/继续抛出异常

}catch(异常类型B e){ 当try中出现B类型异常,就用该catch来捕获

处理异常的代码

//记录日志/打印异常信息/继续抛出异常

}

多catch处理异常示例

/**

多catch捕获处理异常的格式

try{

?

} catch(异常类名 变量名){

?

} catch(异常类名 变量名){

?

} ...catch(异常类名 变量名){

?

}

说明

try代码块

编写可能会出现异常的代码,如果该代码块中的某行代码出现了异常

则try代码块后续的代码不会被执行了

catch代码块：

编写处理异常的代码，如果try代码块中的代码没有出现异常

则catch代码块的代码不会被执行

*/

public class ExceptionDemo02 {
public static void main(String[] args){
int a = 2;
test(a);
}
private static void test(int a) {
try{
/*
1.创建一个对象：ArithmeticException ee = new ArithmeticException("/ by zero");
2.抛出异常对象：ee
*/
int result = 100 / a;
System.out.println("result = " + result);
// 定义字符串
String str = "abc";
/*
1.创建一个对象：NullPointerException ee = new NullPointerException();
2.抛出异常对象：ee
*/
System.out.println(str.length());
// 定义一个数组
int[] arr = {1,2,3};
/*
1.创建一个对象：ArrayIndexOutOfBoundsException ee = new ArrayIndexOutOfBoundsException("3");
2.抛出异常对象：ee
*/
System.out.println(arr[2]);
System.out.println(str.charAt(4));
} catch (NullPointerException e){
System.out.println("又来了没");
} catch (ArithmeticException e){
System.out.println("来了没");
} catch (ArrayIndexOutOfBoundsException e){
System.out.println("又来了吗");
} catch (Exception e){
System.out.println("来多少次了");
}
System.out.println("来这里");
}
}

多catch捕获处理需要注意的是

try代码块中不可能同时出现两个异常，多个catch代码块不可能同时执行两个

多个异常类名之间有继承关系，则父类类型要放在子类类型下面

多个异常类名之间没有继承关系，则没有顺序要求

3 抛出异常throw和声明异常throws

throw关键字作用

用来抛出异常对象，将异常对象抛给方法调用者，并结束当前方法的运行

throw关键字使用格式

throw 异常对象;

throw关键字的使用位置：使用在方法体中

throws关键字作用

用来声明异常，告诉方法调用者方法可能会出现的异常有哪些，让调用者对异常进行处理

throws关键字使用格式

修饰符 返回值类型 方法名(参数列表)throws 异常类名,... {}

throws关键字的使用位置：使用在方法声明上

示例

public class ExceptionDemo03 {
public static void main(String[] args){
int a = 0;
test(a);
}
private static void test(int a) throws ArithmeticException,NullPointerException {
/*
1. 创建异常对象：ArithmeticException e new ArithmeticException("/ by zero");
2. 抛出异常对象：throw e;
*/
if(a == 0){
// 创建异常对象
ArithmeticException e = new ArithmeticException("除数不为零");
// 抛出异常对象
throw e;
}
int result = 100 / a ;
System.out.println("result = " + result);
System.out.println("这里来");
}
}

4 finally 代码块

finally代码块的特点

只要代码执行流程进入了try代码块，不管是否出现异常，该代码块中的代码都会执行

finally代码块的作用

用来释放资源，比如关闭流，关闭数据库资源

捕获处理的完整格式

try{

?

} catch(异常类名 变量名){

?

} finally{

?

}

示例

public class ExceptionDemo04 {
public static void main(String[] args){
int a = 2;
System.out.println(test(a));
}
private static int test(int a) {
if (a != 0){
try{
/*
1.创建一个对象：ArithmeticException ee = new ArithmeticException("/ by zero");
2.抛出异常对象：ee
*/
int result = 100 / a;
System.out.println("result = " + result); // 50
// 退出JVM，终止程序运行，不会执行finally代码块了
System.exit(0);
return 200;
} catch (Exception e){
System.out.println("来了没");
} finally {
System.out.println("释放资源");
}
}
System.out.println("这里来");
return 100;
}
}

5方法重写异常处理注意点

方法重写时异常处理注意事项(针对编译时异常)

子类重写方法时声明的异常不能大于父类方法声明的异常

6编译时异常和运行时异常

编译时异常的概念

除了运行时异常以为的所有的异常都是编译时异常

运行时异常的概念

只要是RuntimeException或RuntimeException的子类异常都属于运行时异常

运行时异常的特点

方法体中如果抛出的异常是运行时异常，则可以处理，也可以处理

方法声明上声明的异常如果是运行时异常，则方法调用者可以处理，也可以不处理。

编译时异常的特点

方法体中如果抛出的异常是编译时异常，则要求必须要处理

方法声明上声明的异常如果是编译时异常，则要求调用者一定要处理

为什么java编译器对运行时异常管理如此松散？

因为运行时异常一般是可以通过程序猿良好的编程习惯避免