【Java】异常处理及其语法、抛出异常、自定义异常（完结）

🌺个人主页：Dawn黎明开始

🎀系列专栏：Java
⭐每日一句：道阻且长，行则将至

📢欢迎大家：关注🔍+点赞👍+评论📝+收藏⭐️

文章目录

一.🔐异常处理及其语法

📋前言

1.1🔓try...catch语句

1.1.1🔑语法格式

1.1.2🔑注意事项

1.1.3🔑异常处理流程

1.1.4🔑案例演示

1.2🔓finally语句

1.2.1🔑语法格式

1.2.2🔑异常处理流程

1.2.3🔑案例演示

二.🔐抛出异常

📋前言

2.1🔓throws关键字

2.1.1🔑语法格式

2.1.2🔑案例演示1

2.1.3🔑案例演示2

2.1.4🔑案例演示3

2.2🔓throw关键字

2.2.1🔑语法格式

2.2.2🔑throw关键字抛出异常

2.2.3🔑案例演示

三.🔐自定义异常类

3.1🔑自定义异常示例代码

3.2🔑案例演示1

3.3🔑案例演示2

📝全文总结

一.🔐异常处理及其语法

📋前言

在Java中，通过try、catch、finally、throw、throws这5个关键字进行异常对象的处理。具体说明如下所示。

1.1🔓try...catch语句

1.1.1🔑语法格式

为了使发生异常后的程序代码正常执行，程序需要捕获异常并进行处理，Java提供了try…catch语句用于捕获并处理异常。try…catch语句的语法格式如下所示：

try{

代码块

} catch(ExceptionType e){

代码块

}

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代码块。

try{

代码块

} catch(ExceptionType e){

代码块

} 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🔑语法格式

修饰符返回值类型方法名(参数1，参数2，…)throws 异常类1, 异常类2...{

方法体

}

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关键字抛出异常

使用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关键字在方法中声明异常的实例对象，语法格式如下：

throw Exception 异常对象

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;        // 将结果返回
             }
    }

运行结果👇🏻