2020.10.27收获+动手动脑五续

2、受控的异常

throws语句

• throws语句表明某方法中可能出现某种（或多种)异常，但它自己不能处理这些异常，而需要由调用者来处理
• 当一个方法包含throws子句时，需要在调用此方法的代码中使用try/catch/finally进行捕获，或者是重新对其进行声明，否则编译时报错

受控与不受控的异常

抛出多个受控异常的方法：

ThrowMultiExceptionsDemo.java

import java.io.*;
public class ThrowMultiExceptionsDemo 
{ 
    public static void main(String[] args) 
    { 
      try 
      { 
            throwsTest(); 
       } 
        catch(IOException e) 
    { 
            System.out.println("捕捉异常"); 
        }
    }

    private static void throwsTest()  throws ArithmeticException,IOException 
    { 
        System.out.println("这只是一个测试"); 
        // 程序处理过程假设发生异常
        throw new IOException(); 
        //throw new ArithmeticException(); 
    } 
}

注：当一个方法声明抛出多个异常时，在此方法调用语句处只要catch其中任何一个异常，代码就可以顺利编译。

OverrideThrows.java

import java.io.*;


public class OverrideThrows
{
    public void test()throws IOException
    {
        FileInputStream fis = new FileInputStream("a.txt");
    }
}
class Sub extends OverrideThrows
{
    //如果test方法声明抛出了比父类方法更大的异常,比如Exception
    //则代码将无法编译……
    public void test() throws FileNotFoundException
    {
            //...
    }
}

3、自定义异常与异常处理链

异常处理链

在实际开发中，经常需要将特定的“过于专业”的异常转换为一个“业务”异常，然后在调用者处进行捕获与处理

ExceptionLinkInRealWorld.java

/**
 * 自定义的异常类
 * @author JinXuLiang
 *
 */
class MyException extends Exception
{
    public MyException(String Message) 
   {
        super(Message);
    }
    public MyException(String message, Throwable cause) 
    {
        super(message, cause);
    }
     public MyException( Throwable cause) 
    {
        super(cause);
    }

}

public class ExceptionLinkInRealWorld 
{
   public static void main( String args[] )
   {
      try 
      {
         throwExceptionMethod();  //有可能抛出异常的方法调用
      }
      catch ( MyException e )
      {
         System.err.println( e.getMessage() );
         System.err.println(e.getCause().getMessage());
      }
      catch ( Exception e )
      {
         System.err.println( "Exception handled in main" );
      }
      doesNotThrowException(); //不抛出异常的方法调用
   }

   public static void throwExceptionMethod() throws MyException
   {
      
      try 
      {
         System.out.println( "Method throwException" );

         throw new Exception("系统运行时引发的特定的异常");  // 产生了一个特定的异常
      }
      catch( Exception e )
      {
         System.err.println(
            "Exception handled in method throwException" );
         //转换为一个自定义异常，再抛出
         throw new MyException("在方法执行时出现异常",e);
         
      }
      finally 
      {
         System.err.println(
            "Finally executed in throwException" );
      }

      // any code here would not be reached
   }

   public static void doesNotThrowException()
   {
      try 
      {
         System.out.println( "Method doesNotThrowException" );
      }
      catch( Exception e )
      {
         System.err.println( e.toString() );
      }
      finally 
      {
         System.err.println(
            "Finally executed in doesNotThrowException" );
      }

      System.out.println(
         "End of method doesNotThrowException" );
   }
}

在实际开发中，可以参照该示例的做法，定义一些与业务逻辑相关的自定义异常类，供上层代码进行捕获，从而能更精确地反映系统真实运行情况并及时进行处理