Java 学习之路 之 使用throw抛出异常（四十七）

    当程序出现错误时，系统会自动抛出异常：除此之外，Java 也允许程序自行抛出异常，自行抛出异常使用 throw 语句来完成（注意此处的 throw 没有后面的 s，与前面声明抛出的 throws 是有区别的）。

1，抛出异常

    异常是一种很“主观”的说法，以下雨为例，假设大家约好明天去爬山郊游，如果第二天下雨了，这种情况会打破既定计划，就属于一种异常：但对于正在期盼天降甘霖的农民而言，如果第二天下雨了，他们正好随雨追肥，这就完全正常。

    很多时候，系统是否要抛出异常，可能需要根据应用的业务需求来决定，如果程序中的数据、执行与既定的业务需求不符，这就是一种异常。由于与业务需求不符而产生的异常，必须由程序员来决定抛出，系统无法抛出这种异常。

    如果需要在程序中自行抛出异常，则应使用 throw 语句，throw 语句可以单独使用，throw 语句抛出的不是异常类，而是一个异常实例，而且每次只能抛出一个异常实例。throw 语句的语法格式如下：

throw ExceptionInstance

    可以利用 throw 语句再次改写前面五子棋游戏中处理用户输入的代码：

try
{
  //将用户输入的字符串以逗号（,）作为分隔符，分隔成两个字符串
  //将两个字符串转换成用户下棋的坐标
  int xPos = Integer.parseInt(posStrArr[0]);
  int yPos = Integer.parseInt(posStrArr[1]);
  //如果用户试图下棋的坐标点已经有棋了，程序自行抛出异常
  if (!gb.board[xPos - 1][yPos - 1].equalst("＋"))
  {
    throw new Exception("您试图下棋的坐标点已经有棋了");//1
  }
  //把对应的数组元素赋为"·"
  gb.board[xPos - 1][yPost - 1] = "·"
}
catch (Exception e)
{
  System.out.println("您输入的坐标不合法，请重新输入，下棋坐标应为x,y的格式：");
  continue;
}

    上面程序中 1 代码使用 throw 语句来自行抛出异常，程序认为当用户试图向一个已有棋子的坐标点下棋就是异常。当 Java 运行时接收到用户自行抛出的异常时，同样会中止当前的执行流，跳到该异常对应的 catch 块，由该 catch 块来处理该异常。也就是说，不管是系统自动抛出的异常，还是程序员手动抛出的异常，Java 运行时环境对异常的处理没有任何差别。

    如果 throw 语句抛出的异常是 Checked 异常，则该 throw 语句要么处于 try 块里，显式捕获该异常，要么放在一个带 throws 声明抛出的方法中，即把该异常交给该方法的调用者处理：如果 throw 语句抛出的异常是 Runtime 异常，则该语句无须放在 try 块里，也无须放在带 throws 声明抛出的方法中；程序既可以显式使用 try...catch 来捕获并处理该异常，也可以完全不理会该异常，把该异常交给该方法调用者处理。例如下面例子程序。

package com.sym.demo5;
 
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，不符合要求");
        }
    }
}

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

2，自定义异常类

    在通常情况下，程序很少会自行抛出系统异常，因为异常的类名通常也包含了该异常的有用信息。所以在选择抛出异常时，应该选择合适的异常类，从而可以明确地描述该异常情况。在这种情形下．应用程序常常需要抛出自定义异常。

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

    下面例子程序创建了一个自定义异常类。

package com.sym.demo5;
 
public class AuctionException extends Exception {
    //无参数的构造器
    public AuctionException(){}//1
    //带一个字符串参数的构造器
    public AuctionException(String msg){//2
        super(msg);
    }
}

    上面程序创建了 AuctionException 异常类，并为该异常类提供了两个构造器。尤其是②号代码部分创建的带一个字符串参数的构造器，其执行体也非常简单，仅通过 super 来调用父类的构造器，正是这行 super 调用可以将此字符串参数传给异常对象的 message 属性，该 message 属性就是该异常对象的详细描述信息。

    如果需要白定义 Runtime 异常，只需将 AuctionException.java 程序中的 Exception 基类改为 RuntimeException 基类，其他地方无须修改。

    在大部分情况下，创建自定义异常都可采用与 AuctionException.java 相似的代码完成只需改变 AuctionException 异常的类名即可，让该异常类的类名可以准确描述该异常。

3，catch 和 throw 同时使用

    前面介绍的异常处理方式有如下两种。

    在出现异常的方法内捕获并处理异常，该方法的调用者将不能再次捕获该异常。

    该方法签名中声明抛出该异常，将该异常完全交给方法调用者处理。

    在实际应用中往往需要更复杂的处理方式——当一个异常出现时，单靠某个方法无法完全处理该异常，必须由几个方法协作才可完全处理该异常。也就是说，在异常出现的当前方法中，程序只对异常进行部分处理，还有些处理需要在该方法的调用者中才能完成，所以应该再次抛出异常，让该方法的调用者也能捕获到异常。

    为了实现这种通过多个方法协作处理同一个异常的情形，可以在 catch 块中结合 throw 语句来完成。如下例子程序示范了这种 catch 和 throw 同时使用的方法。

public class AuctionTest
{
    private double initPrice = 30.0;
    // 因为该方法中显式抛出了AuctionException异常，
    // 所以此处需要声明抛出AuctionException异常
    public void bid(String bidPrice)
        throws AuctionException
    {
        double 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) 
    {
        AuctionTest at = new AuctionTest();
        try
        {
            at.bid("df");
        }
        catch (AuctionException ae)
        {
            // 再次捕捉到bid方法中的异常。并对该异常进行处理
            System.err.println(ae.getMessage());
        }
    }
}

    上面程序中 bid() 方法代码对应的 catch 块捕获到异常后，系统打印了该异常的跟踪栈信息，接着抛出一个 AuctionException 异常，通知该方法的调用者再次处理该 AuctionException 异常。所以程序中的 main 方法，也就是 bid() 方法调用者还可以再次捕获 AuctionException 异常，并将该异常的详细描述信息输出到标准错误输出。

    这种 catch 和 throw 结合使用的情况在大型企业级应用中非常常用。企业级应用对异常的处理通常分成两个部分：① 应用后台需要通过日志来记录异常发生的详细情况；② 应用还需要根据异常向应用使用者传达某种提示。在这种情形下，所有异常都需要两个方法共同完成，也就必须将 catch 和 throw 结合使用。

4，Java 7 增强的 throw 语句

对应如下代码：

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

    上面代码片段中的 1 代码处再次抛出了捕获到的异常，但这个 ex 对象的情况比较特殊：程序捕获该异常时，声明该异常的类型为 Exception；但实际上 try 块中可能只调用了 FileOutputStream 构造器，这个构造器声明只是抛出了 FileNotFoundException 异常。

    在 Java 7 以前，Java 编译器的处理“简单而粗暴”——由于在捕获该异常时声明 ex 的类型是 Exception，因此 Java 编译器认为这段代码可能抛出 Exception 异常，所以包含这段代码的方法通常需要声明抛出 Exception 异常。例如如下方法。

public class ThrowTest2
{
    public static void main(String[] args)
        // Java 6认为①号代码可能抛出Exception，
        // 所以此处声明抛出Exception
        throws Exception
    {
        try
        {
            new FileOutputStream("a.txt");
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            throw ex;        //①
        }
    }
}

    从 Java 7 开始．Java 编译器会执行更细致的检查，Java 编译器会检查 throw 语句抛出异常的实际类型，这样编译器知道①号代码处实际上只可能抛出 FileNotFoundException 异常，因此在方法签名中只要声明抛出 FileNotFoundException 异常即可。即可以将代码改为如下形式（程序清单同上）。

public class ThrowTest2
{
    public static void main(String[] args)
        // Java 7会检查①号代码可能抛出异常的实际类型，
        // 因此此处只需声明抛出FileNotFoundException即可。
        throws FileNotFoundException
    {
        try
        {
            new FileOutputStream("a.txt");
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            throw ex;        //①
        }
    }
}

5，异常链

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

    对于一个采用图 10.5 所示结构的应用，当业务逻辑层访问持久层出现 SQLException 异常时，程序不应该把底层的 SQLExccption 异常传到用户界面，有如下两个原因。 

    ①，对于正常用户而言，他们不想看到底层 SQLException 异常，SQLExccption 异常对他们使用该系统没有任何帮助。

    ②，对于恶意用户而言，将 SQLException 异常暴露出来不安全。

    把底层的原始异常直接传给用户是一种不负责任的表现．通常的做法是：程序先捕获原始异常，然后抛出一个新的业务异常，新的业务异常中包含了对用户的提示信息，这种处理方式被称为异常转译。假设程序需要实现工资计算的方法，则程序应该采用如下结构的代码来实现该方法。

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

    这种把原始异常信息隐藏起来，仅向上提供必要的异常提示信息的处理方式，可以保证底层异常不会扩散到表现层，可以避免向上暴露太多的实现细节，这完全符合面向对象的封装原则。

    这种把捕获一个异常然后接着抛出另一个异常，井把原始异常信息保存下来是一种典型的链式处理（23种设计模式之一：职责链模式），也被称为“异常链”。

    在 JDK l.4 以前，程序员必须自己编写代码来保持原始异常信息。从 JDK l.4 以后，所有 Throwable 的子类在构造器中都可以接收一个 cause 对象作为参数。这个 cause 就用来表示原始异常，这样可以把原始异常传递给新的异常，使得即使在当前位置创建并抛出了新的异常，你也能通过这个异常链追踪到异常最初发生的位置。如果我们希望上面的 SalException 可以追踪到最原始的异常信息，则可以将该方法改写为如下形式。

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

    上面程序中代码创建 SaIException 对象时，传人了一个 Exception 对象，而不是传入了一个 String 对象，这就需要 SaIException 类有相应的构造器。从 JDK l.4 以后，Throwable 基类已有了一个可以接收 Exception 参数的方法，所以可以采用如下代码来定义 SalException 类。

public class SalException extends Exception
{
    public SalException(){}
    public SalException(String msg)
    {
        super(msg);
    }
    //创建一个可以接受Throwable参数的构造器
    public SalException(Throwable t)
    {
        super(t);
    }
}

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

转载于：https://blog.csdn.net/sym90/article/details/41694371