9.3 使用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业务异常类后，就可以用它来封装原始异常，从而实现对异常的链式处理。
