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声明抛出的⽅法中；程序即可以显式使⽤atch来捕获并处理该异常，也可以完全不理会该异常，将异常交给该⽅法的调⽤者处理：
public class ThrowTest
{
public static void main(String[] args)
{
try
{
// 调⽤声明抛出Checked异常的⽅法，要么显式捕获该异常
// 要么在main⽅法中再次声明抛出
throwChecked(-3);
}
catch (Exception e)
{
System.out.Message());
}
// 调⽤声明抛出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.Message());
}
}
}
---------- 运⾏Java捕获输出窗 ----------
java.lang.NumberFormatException: For input string: "df"
at java.base/jdk.internal.adJavaFormatString(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)
try catch的使用方法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业务异常类后，就可以⽤它来封装原始异常，从⽽实现对异常的链式处理。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。