文章目录
一.🔐异常处理及其语法
📋前言
在Java中，通过try、catch、finally、throw、throws这5个关键字进行异常对象的处理。具体说明如下所示。
1.1🔓try...catch语句
1.1.1🔑语法格式
为了使发生异常后的程序代码正常执行，程序需要捕获异常并进行处理，Java提供了try…catch语句用于捕获并处理异常。try…catch语句的语法格式如下所示：
1.1.2🔑注意事项
（1）try代码块是必需的。
（2）catch代码块和finally代码块都是可选的，但catch代码块和finally代码块至少要出现一个。
（3）catch代码块可以有多个，但捕获父类异常的catch代码块必须位于捕获子类异常的catch代码块后面。
（4）catch代码块必须位于try代码块之后。
1.1.3🔑异常处理流程
由上图可知，程序通过try语句捕获可能出现的异常，如果try语句没有捕获到异常，则直接跳出try…catch语句块执行其他程序；如果在try语句中捕获到了异常，则程序会自动跳转到catch语句中找到匹配的异常类型进行相应的处理。异常处理完毕，最后执行其他程序语句。
1.1.4🔑案例演示
下面通过一个案例使用try…catch语句对异常进行捕获，在本案例中，计算 以0为除数的表达式，运行程序并观察程序的运行结果。
代码如下👇🏻
package Exa;
public class Example02 {
public static void main(String[] args) {
try {
int result = divide(4, 0); //调用divide()方法
System.out.println(result);
} catch (Exception e) { //对异常进行处理
System.out.println("捕获的异常信息为：" + e.getMessage());
}
System.out.println("程序继续向下执行...");
}
//下面的方法实现了两个整数相除
public static int divide(int x, int y) {
int result = x / y; //定义一个变量result记录两个数相除的结果
return result; //将结果返回
}
}
运行结果👇🏻
注意：在try代码块中，发生异常语句后面的代码是不会被执行的，如上述案例中第5行 代码的打印语句就没有执行。
1.2🔓finally语句
1.2.1🔑语法格式
在程序中，有时候会希望一些语句无论程序是否发生异常都要执行，这时就可以在try…catch语句后，加一个finally代码块。
注意：finally代码块必须位于所有catch代码块之后。
1.2.2🔑异常处理流程
由上图可知，在try…catch…finally语句中，不管程序是否发生异常，finally代码块中的代码都会被执行。需要注意的是，如果程序发生异常但是没有被捕获到，在执行完finally代码块中的代码之后，程序会中断执行。
1.2.3🔑案例演示
下面通过一个案例演示try…catch...finally语句块的使用。
代码如下👇🏻
package Exa;
public class Example03 {
public static void main(String[] args) {
//下面的代码定义了一个try…catch…finally语句用于捕获异常
try {
int result = divide(4, 0); //调用divide()方法
System.out.println(result);
} catch (Exception e) { //对捕获到的异常进行处理
System.out.println("捕获的异常信息为：" + e.getMessage());
return; //用于结束当前语句
} finally {
System.out.println("进入finally代码块");
}
System.out.println("程序继续向下…");
}
//下面的方法实现了两个整数相除
public static int divide(int x, int y) {
int result = x / y; //定义一个变量result记录两个数相除的结果
return result; //将结果返回
}
}
运行结果👇🏻
注意：如果在try...catch中执行了System.exit(0)语句，finally代码块不再执行。 System.exit(0)表示退出当前的Java虚拟机，Java虚拟机停止了，任何代码都不能再执行了。
二.🔐抛出异常
📋前言
在实际开发中，大部分情况下我们会调用别人编写的方法，并不知道别人编写的方法是否会发生异常。针对这种情况，Java允许在方法的后面使用throws关键字声明该方法有可能发生的异常，这样调用者在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。
2.1🔓throws关键字
2.1.1🔑语法格式
throws关键字需要写在方法声明的后面，throws后面还需要声明方法中发生异常的类型。
2.1.2🔑案例演示1
代码如下👇🏻
package Exa;
public class Example04 {
public static void main(String[] args) {
int result = divide(4, 2); //调用divide()方法
System.out.println(result);
}
//下面的方法实现了两个整数相除，并使用throws关键字声明抛出异常
public static int divide(int x, int y) throws Exception {
int result = x / y; //定义一个变量result记录两个数相除的结果
return result; //将结果返回
}
}
运行结果👇🏻
分析
第4行代码调用divide()方法时传入的第2个参数为2，程序在运行时不会发生被0除的异常。但是运行程序依然会提示错误，这是因为定义divide()方法时使用throws关键字声明了该方法可能抛出的异常，调用者必须在调用divide()方法时对抛出的异常进行处理，否则就会发生编译错误。
2.1.3🔑案例演示2
下面对案例演示1修改，使用try…catch语句处理divide()方法抛出异常。
代码如下👇🏻
package Exa;
public class Example05 {
public static void main(String[] args) {
//下面的代码定义了一个try…catch语句用于捕获异常
try {
int result = divide(4, 2); //调用divide()方法
System.out.println(result);
} catch (Exception e) { //对捕获到的异常进行处理
e.printStackTrace(); //打印捕获的异常信息
}
}
//下面的方法实现了两个整数相除，并使用throws关键字声明抛出异常
public static int divide(int x, int y) throws Exception {
int result = x / y; //定义一个变量result记录两个数相除的结果
return result; //将结果返回
}
}
运行结果👇🏻
注意：使用throws关键字重抛异常时，如果程序发生了异常，并且上一层调用者也无法 处理异常时，那么异常会继续被向上抛出，最终直到系统接收到异常，终止程序执行。
2.1.4🔑案例演示3
下面修改案例演示2，将divide()方法抛出的异常继续抛出。
代码如下👇🏻
package Exa;
public class Example06 {
public static void main(String[] args)throws Exception {
int result = divide(4, 0); // 调用divide()方法
System.out.println(result);
}
// 下面的方法实现了两个整数相除，并使用throws关键字声明抛出异常
public static int divide(int x, int y) throws Exception {
int result = x / y; // 定义一个变量result记录两个数相除的结果
return result; // 将结果返回
}
}
运行结果👇🏻
分析
在案例演示3中，main()方法继续使用throws关键字将Exception抛出，程序虽然可以通过编译，但从上图的运行结果可以看出，在运行时期由于没有对“/by zero”的异常进行处理，最终导致程序终止运行。
2.2🔓throw关键字
在Java程序中，除了throws关键字，还可以使用throw关键字抛出异常。与throws关键字不同的是，throw关键字用于方法体内，抛出的是一个异常实例，并且每次只能抛出一个异常实例。
2.2.1🔑语法格式
throw ExceptionInstance;
在方法中，通过throw关键字抛出异常后，还需要使用throws关键字或try…catch对异常进行处理。如果throw抛出的是error、RuntimeException或它们的子类异常对象，则无需使用throws关键字或try…catch对异常进行处理。
2.2.2🔑throw关键字抛出异常
（1）当throw关键字抛出的异常是编译时异常时，第一种处理方式是在try代码块里使用throw关键字抛出异常，通过try代码块捕获该异常；第二种处理方式是在一个有throws声明的方法中使用throw关键字抛出异常，把异常交给该方法的调用者处理。
（2）当throw关键字抛出的异常是运行时异常时，程序既可以显式使用try…catch捕获并处理该异常，也可以完全不理会该异常，而把该异常交给方法的调用者处理。
2.2.3🔑案例演示
下面通过一个案例讲解throw关键字的使用。
代码如下👇🏻
package Exa;
public class Example07 {
public static void main(String[] args) {
// 下面的代码定义了一个try…catch语句用于捕获异常
int age = -1;
try {
printAge(age);
} catch (Exception e) { // 对捕获到的异常进行处理
System.out.println("捕获的异常信息为：" + e.getMessage());
}
}
// 定义printAge()输出年龄
public static void printAge(int age) throws Exception {
if(age <= 0){
// 对业务逻辑进行判断，当输入年龄为负数时抛出异常
throw new Exception("输入的年龄有误，必须是正整数！");
}else {
System.out.println("此人年龄为："+age);
}
}
}
运行结果👇🏻
三.🔐自定义异常类
📋前言
Java中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况。例如，两数相除，不允许被除数为负数。此时，就无法使用Java提供的异常类表示该类异常，为了解决这个问题，Java允许用户自定义异常类，自定义的异常类必须继承自Exception或其子类。
3.1🔑自定义异常示例代码
自定义异常类的代码如下👇🏻
package Exa;
public class DivideByMinusException extends Exception{
public DivideByMinusException (){
super(); // 调用Exception无参的构造方法
}
public DivideByMinusException (String message){
super(message); // 调用Exception有参的构造方法
}
}
在实际开发中，如果没有特殊的要求，自定义的异常类只需继承Exception类，在构造方法 中使用super()语句调用Exception的构造方法即可。
使用自定义的异常类，需要用到throw关键字。使用throw关键字在方法中声明异常的实例 对象，语法格式如下：
3.2🔑案例演示1
修改divide()方法，在divide()方法中判断被除数是否为负数，如果为负数，就使用throw关键字在方法中向调用者抛出自定义的DivideByMinusException异常对象。
package Exa;
public class Example08 {
public static void main(String[] args) {
int result = divide(4, -2);
System.out.println(result);
}
//下面的方法实现了两个整数相除
public static int divide(int x, int y) {
if(y<0){
throw new DivideByMinusException("除数是负数");
}
int result = x / y; // 定义一个变量result记录两个数相除的结果
return result; // 将结果返回
}
}
从上图可以看出，程序在编译时就发生了异常。因为在一个方法内使用throw关键字抛出异常对象时，需要使用try…catch语句对抛出的异常进行处理，或者在divide()方法上使用throws关键字声明抛出异常，由该方法的调用者负责处理。但是案例一没有这样做。为了解决上图中出现的问题，对案例演示1进行修改，请看案例演示2。
3.3🔑案例演示2
修改案例演示1，在divide()方法上，使用throws关键字声明该方法抛出DivideByMinusException异常，并在调用divide()方法时使用try…catch语句对异常进行处理。
代码如下👇🏻
package Exa;
public class Example09 {
public static void main(String[] args) {
// 下面的代码定义了一个try…catch语句用于捕获异常
try {
int result = divide(4, -2);
System.out.println(result);
} catch (DivideByMinusException e) { // 对捕获到的异常进行处理
System.out.println(e.getMessage()); // 打印捕获的异常信息
}
}
// 下面的方法实现了两个整数相除，并使用throws关键字声明抛出自定义异常
public static int divide(int x, int y) throws DivideByMinusException{
if (y < 0) {
throw new DivideByMinusException("除数是负数");
}
int result = x / y; // 定义一个变量result记录两个数相除的结果
return result; // 将结果返回
}
}
运行结果👇🏻
📝全文总结
本文主要介绍了异常的处理及语法和抛出异常，最后介绍了自定义异常。通过本文的学习，希望大家对Java中的异常会有一定的了解，掌握好这些知识，对以后的实际开发大有裨益。