9.3 使用throw抛出异常

目录

• 一、抛出异常
• 二、自定义异常类
• 三、catch和throw同时使用
• 四、使用throw语句抛出异常
• 五、异常链

当程序出现错误，系统会自动抛出异常；除此之外，Java也允许程序自行抛出异常，自行抛出异常使用throw语句来完成。

一、抛出异常

系统是否抛出异常，可能需要根据业务需求来决定，如果程序中的数据、执行与既定的业务需求不符，这是一种异常。由于与业务需求不符而产生的异常，必须由程序员来决定抛出，系统无法抛出这种异常。
如果需要在程序中自行抛出异常，则应该使用throw语句，throw语句抛出的不是异常类，而是一个异常类的实例，而且每次都只能抛出一个异常实例。throw语法的格式：

throw ExceptionInstance;

使用throw语句改写五子棋游戏处理用户输入的代码：

    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("╋"))
		{
			throw new Exception("你试图下棋的坐标点已经有棋了");
		}
		gb.board[xPos - 1][yPos - 1] = "●";
	}
	catch (Exception e)
	{
		System.out.println("您输入的坐标不合法，请重新输入，"
			+ "下棋坐标应以x,y的格式");
		continue;
	}

上面程序中throw new Exception("你试图下棋的坐标点已经有棋了");抛出异常，程序认为当用户试图向一个已经有棋子的坐标点下棋就是异常。当Java允许时接收到开发者自行抛出异常时，同样会中止当前流，跳动该异常对应的catch块，由该catch块来处理该异常。
如果throw抛出的异常是Checked异常，则该throw语句要么处在try块中，显式捕获该异常,要么放在一个带throws声明抛出的方法中，即把该异常交给方法的调用者处理;如果throw语句抛出的异常是Runtime异常，那么该语句无须放在try块中，也无须放在带throws声明抛出的方法中；程序即可以显式使用try...catch来捕获并处理该异常，也可以完全不理会该异常，将异常交给该方法的调用者处理：

public class ThrowTest
{
	public static void main(String[] args)
	{
		try
		{
			// 调用声明抛出Checked异常的方法，要么显式捕获该异常
			// 要么在main方法中再次声明抛出
			throwChecked(-3);
		}
		catch (Exception e)
		{
			System.out.println(e.getMessage());
		}

		// 调用声明抛出Runtime异常的方法既可以显式捕获该异常，
		// 也可不理会该异常
		throwRuntime(3);
	}


	public static void throwChecked(int a) throws Exception
	{
		if (a > 0)
		{
			// 自行抛出Exception异常
			// 该代码必须处于try块里，或处于带throws声明的方法中
			throw new Exception("a的值大于0，不符合要求");
		}
	}

	public static void throwRuntime(int a)
	{
		if (a > 0)
		{
			// 自行抛出RuntimeException异常，既可以显式捕获该异常
			// 也可完全不理会该异常，把该异常交给该方法调用者处理
			throw new RuntimeException("a的值大于0，不符合要求");
		}
	}
}
---------- 运行Java捕获输出窗 ----------
Exception in thread "main" java.lang.RuntimeException: a的值大于0，不符合要求
	at ThrowTest.throwRuntime(ThrowTest.java:38)
	at ThrowTest.main(ThrowTest.java:19)

输出完成 (耗时 0 秒) - 正常终止

通过上面的程序可以看出，自行抛出Runtime异常比自行抛出Checked异常的灵活性更好。同样，通过Checked异常可以让编译器提醒程序员必须处理该异常。

二、自定义异常类

用户自定义异常都应该继承Exception基类，如果希望自定义Runtime异常，则应该继承RuntimeException基类。定义异常类时需要提供两个构造器：一个十五参数的构造器；另一个是带有一个字符串参数的构造器，这个字符串作为该异常该异常对象的描述信息（也就是异常对象的getMessage()方法的返回值）。

public class AuctionException extends Exception
{
	//无参数构造器器
	public AuctionException(){}
	//带有一个字符串参数的构造器
	public AuctionException(String msg)
	{
		super(msg);
	}
}

上面创建了一个AuctionException异常类，并未该异常类提供了两个构造器。其中带有参数的构造器，仅通过super调用父类构造器，正是这行super代码可以将字符串参数传给异常对象的message属性，该message属性就是对该异常对象的详细描述信息。
如果需要自定义Runtime异常，只需要将AuctionException.java程序中的Exception基类改为RuntimeException基类，其他地方无须修改。

三、catch和throw同时使用

处理异常的两种方式：
1、在出现异常的方法内捕获并处理异常，该方法的调用者将不能再次捕获该异常。
2、该方法签名中声明抛出该异常，将异常完全交给方法调用者处理
当一个异常出现时，单靠某个方法无法完全处理该异常，必须有几个方法协作才可以完全处理。也就是说，在异常出现的当前方法中，程序只对异常进行部分处理，还有些处理需要在该方法的调用者才能完成，所以该再次抛出异常，让该方法的调用者也能捕获到该异常。
为了实现这种通过多个方法协作处理同一个情形，可以在catch块中结合throw语句来完成。下面展示这种catch和throw同时使用的方法：

public class AuctionTest 
{
	private double initPrice=30.0;

	//因为该方法中显式抛出了AuctionException异常
	//所以此处需要声明抛出AuctionException异常
	public void bid(String bidPrice)
		throws AuctionException
	{
		var d=0.0;
		try
		{
			d=Double.parseDouble(bidPrice);
		}
		catch (Exception e)
		{
			//此处完成本方法中对异常执行的修复处理
			//此处仅仅在控制台打印异常的跟踪栈信息
			e.printStackTrace();
			//再次抛出自定义异常
			throw new AuctionException("竞拍价必须是整数，不能包含其他字符！");
		}
		if(initPrice>d)
		{
			throw new AuctionException("竞拍起价比拍价低，不允许竞拍！");
		}
		initPrice=d;
	}
	public static void main(String[] args) 
	{
		var at=new AuctionTest();
		try
		{
			at.bid("df");
		}
		catch (AuctionException ae)
		{
			//再次捕获bid()方法中的异常，并对该异常进行处理
			System.out.println(ae.getMessage());
		}
	}
}
---------- 运行Java捕获输出窗 ----------
java.lang.NumberFormatException: For input string: "df"
	at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2054)
	at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.base/java.lang.Double.parseDouble(Double.java:549)
	at AuctionTest.bid(AuctionTest.java:13)
	at AuctionTest.main(AuctionTest.java:34)
竞拍价必须是整数，不能包含其他字符！

输出完成 (耗时 0 秒) - 正常终止

上面程序中catch块捕获到异常后，系统打印异常的跟踪栈信息，接着抛出一个AuctionException异常，通知该方法的调用者再次处理该AuctionException异常.

四、使用throw语句抛出异常

try
{
    new FileOutputStream("a.txt");
}
catch (Exception ex)
{
    ex.printStackTrace();
    throw ex;//①
}

上面代码再次抛出了捕获的异常，但这个异常对象的情况比较特殊：程序捕获该异常，声明该异常的类型为Exception；但实际上try块中可能只调用了FileOutputStream构造器，这个构造器声明只是抛出FileNotFoundException异常。
在Java7以前，编译器处理“简单而粗暴”——由于在捕获该异常时声明ex的类型是Exception。因此Java编译器认为这段代码可能抛出Exception异常，所以包含这段代码的方法通常需要声明抛出Exception异常。
从Java 7开始，Java编译器会执行更加细致的检查，Java编译器会检查throw语句抛出异常的实际类型，这样编译器知道①号代码实际只能抛出FileNotFoundException异常，因此在方法签名中只要声明抛出FileNotFoundException异常。

import java.io.*;
public class ThrowsTest2
{
	public static void main(String[] args)
		//java 6认为①号代码只能抛出Exception
		//所以此处必须声明抛出Exception
		//Java 7会检查①号代码可能抛出异常的实际类型
		//因此此处只需要声明抛出FileNotFoundException异常即可
		throws FileNotFoundException
	{
		try
		{
			var fis=new FileInputStream("a.txt");
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
			throw ex;//①
		}

	}
}
---------- 运行Java捕获输出窗 ----------
java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
	at java.base/java.io.FileInputStream.open0(Native Method)
	at java.base/java.io.FileInputStream.open(FileInputStream.java:213)
	at java.base/java.io.FileInputStream.<init>(FileInputStream.java:155)
	at java.base/java.io.FileInputStream.<init>(FileInputStream.java:110)
	at ThrowsTest2.main(ThrowsTest2.java:13)
Exception in thread "main" java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
	at java.base/java.io.FileInputStream.open0(Native Method)
	at java.base/java.io.FileInputStream.open(FileInputStream.java:213)
	at java.base/java.io.FileInputStream.<init>(FileInputStream.java:155)
	at java.base/java.io.FileInputStream.<init>(FileInputStream.java:110)
	at ThrowsTest2.main(ThrowsTest2.java:13)

输出完成 (耗时 0 秒) - 正常终止

五、异常链

对于真实的企业级应用而言，常常有严格的分层关系，层与层之间有非常清晰的划分，上次功能的实现严格依赖于下层的API，也不会跨层访问。下图显示这种具有分层结构应用的大致示意图：

对于一个采用上图所示的结构应用，当业务逻辑层出现SQLException异常时，程序不应该把底层的SQLException异常传到用户界面，有如下两个原因：
1、对于正常用户而言，它们不想看到底层的SQLException异常，SQLException异常对于他们使用该系统没有任何帮助。
2、对于恶意用户而言，将SQLException异常暴露出来不安全。
通常的做法：程序先捕获原始异常，然后抛出一个新的业务异常，新的业务异常中包含了对用户提示信息，这种处理方式被称为异常转译。
假设程序需要实现工资计算的方法，程序应该采用如下结构的代码来实现该方法：

public void calSal() throws SalException
{
	try
	{
		//实现结算工资的业务
		...
	}
	catch (SQLException sqle)
	{
		//把原始异常记录下来，留给管理员
		...
		//下面的message就是对用户的提示
		throw new SalException("访问底层数据库出现问题");
	}
	catch (Exception e)
	{
		//把原始异常记录下来，留给管理员
		...
		//下面的message就是对用户的提示
		throw new SalException("系统出现未知异常");
	}
}

这种把异常信息异常起来，仅向上提供必要的提示信息处理方式，可以保证底层异常不会扩散到表现层，可以避免向上暴露太多的实现细节，这完全符合面向对象的封装原则。
这种捕获一种异常然后接着抛出另一个异常，并把原始异常信息保存下来是一种典型的链式处理方式（23种设计模式之一：职责链模式），也称为“异常链”
在JDK1.4以前，程序员都必须自己编写代码来保持原始异常信息。从JDK 1.4以后，所有Throwable的子类在构造器可以接受一个cause 对象作为参数。这个cause就用来表示原始异常，这样可以把原始异常传递给新的异常，使得即使在当前位置创建并抛出新的异常，你也能通过该异常链追踪到异常最初发生的位置。希望通过上面的SalException去追踪到最原始的异常信息，则可以将该方法改为下面的形式：

public void calSal() throws SalException
{
	try
	{
		//实现结算工资的业务
		...
	}
	catch (SQLException sqle)
	{
		//把原始异常记录下来，留给管理员
		...
		//下面的sqle就是原始异常
		throw new SalException(sqle);
	}
	catch (Exception e)
	{
		//把原始异常记录下来，留给管理员
		...
		//下面的e就是原始异常
		throw new SalException(e);
	}
}

上面代码抛出异常时，throw new SalException（）传入的参数是一个Exception异常，而不是传入一个String异常，这就需要SalException类有相应的构造器。从JDK 1.4以后，Throwable基类已有一个可以接受Exception参数的方法，所以可以采用以下代码来定义SalException.

public class SalException extends Exception
{
	public SalException(){}
	public SalException(String msg)
	{
		super(msg);
	}
	public SalException(Throwable t)
	{
		super(t);
	}

创建这个SalException业务异常类后，就可以用它来封装原始异常，从而实现对异常的链式处理。