Java面向对象系列[v1.0.0][异常处理机制]

傷城~ 2023-03-13 03:39 72阅读 0赞

异常和测试岗位的理念紧密相关，所以关于异常应该好好说一说，实际上异常机制是判断一门编程语言是否成熟的标准，主流的编程语言中都提供了健全的异常处理机制，请看清楚这里说的是处理机制，它可以使程序中的异常处理代码和正常业务代码分离，保证程序代码更加优雅的展现，而其本质是大大提高了程序的健壮性，反映到客户层面更多的感知就是稳定性

对于计算机语言来说情况相当复杂，没人能保证得了程序永远不会出错，就算程序没有错误，谁又能保证客户是按你的预期来输入的？就算客户是非常聪明而且配合的，谁能保证运行该程序会永久稳定？谁能保证运行程序的物理资源永久配合？谁能保证网络条件永远合适？。。。太多无法保证的东西，人是否要覆盖住？

程序员喜欢的永远是解决问题以及开发带来的创造快感，都不愿意当个堵漏洞的工人，而这才是漏洞的真正概念，而这些也是一个程序员是否成熟的标准

以Java为例，它的异常处理主要依赖于try、catch、finally、throw和throws五个关键字：

*  try代码块中放置可能引发异常的代码，因此程序员判断代码是否会有异常情况，是否需要try代码块来处理就成了关键，try只是工具，关键在人；
 *  catch代码块对应异常类型以及该类型的处理方式；
 *  多个catch代码块后可以跟一个finally代码块它与try代码块相呼应，主要用于回收try代码块里打开的物理资源，而异常处理机制会保证finally代码块总会被执行；
 *  throws关键字主要是用于方法签名，声明该方法可能抛出的异常，而throw用于抛出一个实际的异常

Java的异常分为两种，Checked异常和Runtime异常，Checked异常和Runtime异常，Checked都是可以在编译阶段被处理的异常，因此它强制程序处理所有的Checked异常Runtime异常则无需处理，程序员处理异常是一个繁琐的事情，因此程序的健壮性在人而非try代码块

## 使用try…catch捕获异常 ##

try
    { 
    	// 业务实现代码
    	...
    }
    catch (Exception e)
    { 
    	// 处理异常的代码块
    }

如果程序可以顺利完成，那就一切正常，如果try块里的业务逻辑代码出现异常，系统会自动生成一个异常对象，该异常对象会被提交给Java runtime环境，而这个过程就被称为抛出异常，当抛出异常发生的时候，Java会寻找能够处理该异常对象的catch块，如果找到合适的catch块，则把该异常对象交给该catch块处理，这个过程被称为捕获异常，如果找不到捕获异常的catch块，则Java runtime环境终止，Java程序也会退出  
**无论程序是否出现在try代码块中，只要执行该代码块出现了异常，系统总会自动生成异常对象，如果不处理则程序直接退出**

import java.io.*;
    
    public class Gobang
    { 
    	// 定义一个二维数组来充当棋盘
    	private String[][] board;
    	// 定义棋盘的大小
    	private static int BOARD_SIZE = 15;
    	public void initBoard()
    	{ 
    		// 初始化棋盘数组
    		board = new String[BOARD_SIZE][BOARD_SIZE];
    		// 把每个元素赋为"╋"，用于在控制台画出棋盘
    		for (var i = 0; i < BOARD_SIZE; i++)
    		{ 
    			for (var j = 0; j < BOARD_SIZE; j++)
    			{ 
    				board[i][j] = "╋";
    			}
    		}
    	}
    	// 在控制台输出棋盘的方法
    	public void printBoard()
    	{ 
    		// 打印每个数组元素
    		for (var i = 0; i < BOARD_SIZE; i++)
    		{ 
    			for (var j = 0; j < BOARD_SIZE; j++)
    			{ 
    				// 打印数组元素后不换行
    				System.out.print(board[i][j]);
    			}
    			// 每打印完一行数组元素后输出一个换行符
    			System.out.print("\n");
    		}
    	}
    	public static void main(String[] args) throws Exception
    	{ 
    		var gb = new Gobang();
    		gb.initBoard();
    		gb.printBoard();
    		// 这是用于获取键盘输入的方法
    		var br = new BufferedReader(
    			new InputStreamReader(System.in));
    		String inputStr = null;
    		// br.readLine()：每当在键盘上输入一行内容按回车，
    		// 用户刚刚输入的内容将被br读取到。
    		while ((inputStr = br.readLine()) != null)
    		{ 
    			try
    			{ 
    				// 将用户输入的字符串以逗号作为分隔符，分解成2个字符串
    				String[] posStrArr = inputStr.split(",");
    				// 将2个字符串转换成用户下棋的坐标
    				var xPos = Integer.parseInt(posStrArr[0]);
    				var yPos = Integer.parseInt(posStrArr[1]);
    				// 把对应的数组元素赋为"●"。
    				if (!gb.board[xPos - 1][yPos - 1].equals("╋"))
    				{ 
    					System.out.println("您输入的坐标点已有棋子了，"
    						+ "请重新输入");
    					continue;
    				}
    				gb.board[xPos - 1][yPos - 1] = "●";
    			}
    			catch (Exception e)
    			{ 
    				System.out.println("您输入的坐标不合法，请重新输入，"
    					+ "下棋坐标应以x,y的格式");
    				continue;
    			}
    
    			gb.printBoard();
    			System.out.println("请输入您下棋的坐标，应以x,y的格式：");
    		}
    	}
    }

程序中catch代码块处理了异常后，使用continue忽略本次循环剩下的代码，开始执行下一次循环，这就保证了足够的兼容性，用户可以随意输入，程序不会因为用户输入不合法而突然退出

### 查找catch代码块 ###

当Java runtime环境接收到异常对象的时候，会依次判断该异常对象是否是catch块里的异常类或者其子类的实例，如果是Java runtime将调用该catch块来处理该异常，否则再次拿该异常对象与下一个catch块里的异常类进行比较，如下图所示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhd2VpX3lhbmcwMDAwMDA_size_16_color_FFFFFF_t_70]

## Java异常类的继承体系 ##

如图所示，Java把所有的非正常情况非为两种即：异常(Exception)和错误(Error)，他们都继承Throwable父类  
Error：一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢复或不可能捕获，将导致程序中断，一般情况下应用程序无法处理这些错误，因此应用程序不应该试图使用catch块来捕获Error对象，在定义该方法时，无须在其throws子句中声明该方法可能抛出Error及其任何子类  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhd2VpX3lhbmcwMDAwMDA_size_16_color_FFFFFF_t_70 1]

public class DivTest
    { 
    	public static void main(String[] args)
    	{ 
    		try
    		{ 
    			var a = Integer.parseInt(args[0]);
    			var b = Integer.parseInt(args[1]);
    			var c = a / b;
    			System.out.println("您输入的两个数相除的结果是：" + c );
    		}
    		catch (IndexOutOfBoundsException ie)
    		{ 
    			System.out.println("数组越界：运行程序时输入的参数个数不够");
    		}
    		catch (NumberFormatException ne)
    		{ 
    			System.out.println("数字格式异常：程序只能接受整数参数");
    		}
    		catch (ArithmeticException ae)
    		{ 
    			System.out.println("算术异常");
    		}
    		catch (Exception e)
    		{ 
    			System.out.println("未知异常");
    		}
    	}
    }

上面程序针对IndexOutOfBoundsException、NumberFormatException、ArithmeticException类型的异常，提供了专门的异常处理逻辑。  
Java运行时的异常处理逻辑可能有如下几种情形：

*  如果运行该程序时输入的参数不够，将会发生数组越界异常，Java运行时将调用IndexOutOfBoundsException对应的catch块处理该异常
 *  如果运行该程序时输入的参数不是数字，而是字母，将发生数字格式异常, Java运行时将会调用NumberFormatException对应的catch块处理该异常
 *  如果运行该程序时输入的第二个参数是0，将会发生除0异常，Java运行时将会调用ArithmeticException对应的catch块处理该异常
 *  如果程序运行时出现其他异常，该异常对象总是Exception类或其子类的实例，Java运行时将调用Exception对象的catch块处理该异常

import java.util.*;
    
    public class NullTest
    { 
    	public static void main(String[] args)
    	{ 
    		Date d = null;
    		try
    		{ 
    			System.out.println(d.after(new Date()));
    		}
    		catch (NullPointerException ne)
    		{ 
    			System.out.println("空指针异常");
    		}
    		catch (Exception e)
    		{ 
    			System.out.println("未知异常");
    		}
    	}
    }

当试图调用一个null对象的实例方法或实例变量的时，就会引发NullPointerException异常，Java运行时会调用NullPointerException对应的catch块来处理该异常，如果遇到其他异常则调用最后的catch块来处理异常

> **注意：Exception类的catch块必须方法最后，因为所有的异常对象都是Exception或其子类的实例，如果Exception类的catch块在前边，那么它后边的catch块将永远不会获得执行**

实际上进行异常捕获的时候不仅应该把Exception类对应的catch块放在最后，而且所有父类异常的catch块都应该排在子类异常catch块后面，也就是先处理小异常再处理大异常，否则将出现编译错误

try
    { 
    	statements...
    }
    catch (RuntimeException e)
    { 
    	System.out.println("运行时异常");
    }
    catch (NullPointerException ne)
    { 
    	System.out.println("空指针异常");
    }

因为RuntimeException已经包括了NullPointerException异常，所以`catch (NullPointerException ne)`处的catch块永远不会获得执行的机会

## 多异常捕获 ##

在Java7之后，一个catch块可以捕获多种类型的异常，只需要在多种异常类型之间使用竖线(|)隔开，并且异常变量有隐式的final修饰，因此程序不能对异常变量重新赋值

public class MultiExceptionTest
    { 
    	public static void main(String[] args)
    	{ 
    		try
    		{ 
    			var a = Integer.parseInt(args[0]);
    			var b = Integer.parseInt(args[1]);
    			var c = a / b;
    			System.out.println("您输入的两个数相除的结果是：" + c );
    		}
    		catch (IndexOutOfBoundsException|NumberFormatException
    			|ArithmeticException ie)
    		{ 
    			System.out.println("程序发生了数组越界、数字格式异常、算术异常之一");
    			// 捕捉多异常时，异常变量默认有final修饰，
    			// 所以下面代码有错：
    			ie = new ArithmeticException("test");  
    		}
    		catch (Exception e)
    		{ 
    			System.out.println("未知异常");
    			// 捕捉一个类型的异常时，异常变量没有final修饰
    			// 所以下面代码完全正确。
    			e = new RuntimeException("test");    
    		}
    	}
    }

## 访问异常类信息 ##

如果程序需要在catch块中访问异常对象的相关信息，可以通过访问catch块的后异常形参来获得，当Java运行时决定调用某个catch块来处理该异常对象时，会将异常对象赋给catch块后的异常参数，程序即可通过该参数来获得异常的相关信息  
所有的异常对象都包含了如下几个常用方法：

*  getMessage():返回该异常的详细描述字符串
 *  printStackTrace():将该异常的跟踪栈信息输出到标准错误输出
 *  printStackTrace(PrintStream s): 将该异常的跟踪栈信息输出到指定输出流
 *  getStackTrace():返回该异常的跟踪栈信息

import java.io.*;
    
    public class AccessExceptionMsg
    { 
    	public static void main(String[] args)
    	{ 
    		try
    		{ 
    			var fis = new FileInputStream("a.txt");
    		}
    		catch (IOException ioe)
    		{ 
    			System.out.println(ioe.getMessage());
    			ioe.printStackTrace();
    		}
    	}
    }

## finally块的作用 ##

Java的垃圾回收机制不会回收任何物理资源，垃圾回收机制只能回收堆内存中对象所占用的内存，而程序在try代码块里打开的物理资源如数据库连接、网络资源、磁盘文件等，这些资源都必须显示的回收，而这些显示的回收应该在finally块中做，因为无论try和catch执行的什么，finally代码块总会被执行

try
    { 
    	// 业务代码
    	...
    }
    catch (SubException e)
    { 
    	// 异常处理代码块
    }
    catch (SubException e)
    { 
    	// 异常处理代码块
    }
    ...
    finally
    { 
    	// 资源回收代码块
    	...
    }

*  异常处理机制中必须有try代码块，catch和finally都是可选的，但catch和finally必须有其一，也可以同时有
 *  可以有多个catch块，捕获父类异常的catch块必须位于捕获子类异常的后面
 *  不能只有try代码块，既没有catch也没有finally
 *  多个catch代码块必须位于try代码块之后，finally块必须位于所有的catch块之后

import java.io.*;
    
    public class FinallyTest
    { 
    	public static void main(String[] args)
    	{ 
    		FileInputStream fis = null;
    		try
    		{ 
    			fis = new FileInputStream("a.txt");
    		}
    		catch (IOException ioe)
    		{ 
    			System.out.println(ioe.getMessage());
    			// return语句强制方法返回
    			return;       
    			// 使用exit来退出虚拟机
    			System.exit(1);    
    		}
    		finally
    		{ 
    			// 关闭磁盘文件，回收资源
    			if (fis != null)
    			{ 
    				try
    				{ 
    					fis.close();
    				}
    				catch (IOException ioe)
    				{ 
    					ioe.printStackTrace();
    				}
    			}
    			System.out.println("执行finally块里的资源回收!");
    		}
    	}
    }

*  **即便有return强制方法返回，但仍旧会执行finally代码块里的代码**
 *  **System.exit(1)强制退出JVM，这种退出的话finally就没机会执行了**
 *  **如果在finally块中使用了return或throw语句，将会导致try代码块、catch代码块中的return、throw语句失效**

public class FinallyFlowTest
    { 
    	public static void main(String[] args)
    		throws Exception
    	{ 
    		boolean a = test();
    		System.out.println(a);
    	}
    	public static boolean test()
    	{ 
    		try
    		{ 
    			// 因为finally块中包含了return语句
    			// 所以下面的return语句失去作用
    			return true;
    		}
    		finally
    		{ 
    			return false;
    		}
    	}
    }

当系统遇到try和catch里的return或者throw语句的时候，都会立即终止执行当前方法，当方法执行并未结束，且return和throw语句也未执行，然后程序去寻找finally代码块，如果没有finally代码块程序立即执行return或throw语句方法终止，如果有finally代码块，系统立即执行finally代码块，当finally代码块执行完毕后系统才会跳回去执行try代码块、catch代码块里的return或throw语句，如果finally里也使用了return或throw等导致方法终止的语句，finally代码块就终止了系统也不会跳回去执行try代码块、catch代码块里的任何代码了

## 自动关闭资源的try语句 ##

当程序使用finally代码块关闭资源时，显得非常臃肿，Java7之后允许try关键字后跟一对圆括号用于声明、初始化一个或多个资源，然后try语句在该语句结束时自动关闭这些资源，从而降低了代码的臃肿  
需要说明的是，要保证try语句可以正常关闭资源，这些资源实现类必须实现AutoCloseable或Closeable接口，实现这两个接口就必须实现close()方法

>  *  Closeable是AutoCloseable的子接口，可以被自动关闭的资源类要么实现AutoCloseable接口，要么实现Closeable接口
>  *  Closeable接口里的close()方法声明抛出了IOException，因此它的实现类在实现close()方法时只能声明抛出IOException或其子类
>  *  AutoCloseable接口里的close()方法声明抛出了Exception，因此它的实现类在实现close()方法时可以声明抛出任何异常

import java.io.*;
    
    public class AutoCloseTest
    { 
    	public static void main(String[] args)
    		throws IOException
    	{ 
    		try (
    			// 声明、初始化两个可关闭的资源
    			// try语句会自动关闭这两个资源。
    			var br = new BufferedReader(
    				new FileReader("AutoCloseTest.java"));
    			var ps = new PrintStream(new
    				FileOutputStream("a.txt")))
    		{ 
    			// 使用两个资源
    			System.out.println(br.readLine());
    			ps.println("庄生晓梦迷蝴蝶");
    		}
    	}
    }

自动关闭资源的try语句相当于包含了隐式的finally代码块，因此这个代码既没有catch也没有finally，Java7之后几乎所有的资源类，包括文件IO的各种类、JDBC的Connection、Statement等接口进行了改写，改写后资源类都实现了AutoCloseable或Closeable接口

Java9之后不要求在try后的圆括号内声明并创建资源，只需要自动关闭的资源有final修饰或者是有效的final，在Java9之后改写上面的代码

import java.io.*;
    
    public class AutoCloseTest2
    { 
    	public static void main(String[] args)
    		throws IOException
    	{ 
    		// 有final修饰的资源
    		final var br = new BufferedReader(
    			new FileReader("AutoCloseTest.java"));
    		// 没有显式使用final修饰，但只要不对该变量重新赋值，按该变量就是有效的final
    		var ps = new PrintStream(new
    			FileOutputStream("a.txt"));
    		// 只要将两个资源放在try后的圆括号内即可
    		try (br; ps)
    		{ 
    			// 使用两个资源
    			System.out.println(br.readLine());
    			ps.println("庄生晓梦迷蝴蝶");
    		}
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhd2VpX3lhbmcwMDAwMDA_size_16_color_FFFFFF_t_70]: /images/20230312/e5c7beca9aac4696a1f148027ec07853.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhd2VpX3lhbmcwMDAwMDA_size_16_color_FFFFFF_t_70 1]: /images/20230312/ba715d92da7c4fcab7a1f360123043c1.png