动手动脑5（04-异常处理）

10.27（04-异常处理）

1.请阅读并运行AboutException.java示例，然后通过后面的几页PPT了解Java中实现异常处理的基础知识。

import javax.swing.*;
 
class AboutException {
   public static void main(String[] a) 
   {
      int i=1, j=0, k;
      k=i/j;
 
 
    try
    {
         
        k = i/j;    // Causes division-by-zero exception
        //throw new Exception("Hello.Exception!");
    }
     
    catch ( ArithmeticException e)
    {
        System.out.println("被0除.  "+ e.getMessage());
    }
     
    catch (Exception e)
    {
        if (e instanceof ArithmeticException)
            System.out.println("被0除");
        else
        {  
            System.out.println(e.getMessage());
             
        }
    }
 
     
    finally
        {
            JOptionPane.showConfirmDialog(null,"OK");
        }
         
  }
}

运行结果：

Java中的异常捕获语句

Try{

//可能发生运行错误的代码；

}

catch（异常类型异常对象引用）{

//用于处理异常的代码

}

finally{

//用于“善后” 的代码

}

Java 中所有可捕获的异常都派生自 Exception 类。

多层的异常捕获：

（1）阅读以下代码（CatchWho.java），写出程序运行结果：

public class CatchWho 
{ 
    public static void main(String[] args) 
    { 
        try
    { 
                try
        { 
                    throw new ArrayIndexOutOfBoundsException(); 
                } 
                catch(ArrayIndexOutOfBoundsException e) 
        { 
                    System.out.println(  "ArrayIndexOutOfBoundsException" +  "/内层try-catch"); 
                }
  
            throw new ArithmeticException(); 
        } 
        catch(ArithmeticException e) 
    { 
            System.out.println("发生ArithmeticException"); 
        } 
        catch(ArrayIndexOutOfBoundsException e) 
    { 
           System.out.println(  "ArrayIndexOutOfBoundsException" + "/外层try-catch"); 
        } 
    } 
}

运行结果：

（2）写出CatchWho2.java程序运行的结果

public class CatchWho2 
{ 
    public static void main(String[] args) 
    { 
        try
    {
                try
        { 
                    throw new ArrayIndexOutOfBoundsException(); 
                } 
                catch(ArithmeticException e) 
        { 
                    System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch"); 
                }
            throw new ArithmeticException(); 
        } 
        catch(ArithmeticException e) {
      
            System.out.println("发生ArithmeticException"); 
        } 
        catch(ArrayIndexOutOfBoundsException e) 
    { 
            System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch"); 
        } 
    } 
}

运行结果：

3.当有多个嵌套的try…catch…finally时，要特别注意finally的执行时机。

请先阅读 EmbedFinally.java示例，再运行它，观察其输出并进行总结。

特别注意：当有多层嵌套的finally时，异常在不同的层次抛出，在不同的位置抛出，可能会导致不同的finally语句块执行顺序。

public class EmbededFinally 
{
 
    public static void main(String args[]) 
    {
         
        int result;
         
        try
        {
             
            System.out.println("in Level 1");
 
            try
            {
                 
                System.out.println("in Level 2");
  // result=100/0;  //Level 2
                
                try
                {
                    
                    System.out.println("in Level 3");
                       
                    result=100/0;  //Level 3
                 
                } 
                 
                catch (Exception e) 
                {
                     
                    System.out.println("Level 3:" + e.getClass().toString());
                 
                }
                 
                finally
                {
                     
                    System.out.println("In Level 3 finally");
                 
                }
                 
                // result=100/0;  //Level 2
 
                }
             
            catch (Exception e) 
            {
                
                System.out.println("Level 2:" + e.getClass().toString());
            
            }
            finally
            {
                 
                System.out.println("In Level 2 finally");
            
             }
              
            // result = 100 / 0;  //level 1
         
        } 
         
        catch (Exception e) 
        {
             
            System.out.println("Level 1:" + e.getClass().toString());
         
        }
         
        finally
        {
            
.           System.out.println("In Level 1 finally");
         
        }
     
    }
 
}

运行结果：

总结：try...catch语句为配对出现，程序会按着代码的顺序依次执行，当try中语句出现异常时，他会执行与当前try配对的catch语句。

4.辨析：finally语句块一定会执行吗？

请通过 SystemExitAndFinally.java示例程序回答上述问题

public class SystemExitAndFinally 
{
 
    public static void main(String[] args)
     
    {
         
        try
        {
 
            System.out.println("in main");
             
            throw new Exception("Exception is thrown in main");
 
                    //System.exit(0);
 
        }
         
        catch(Exception e)
 
            {
             
            System.out.println(e.getMessage());
             
            System.exit(0);
         
        }
         
        finally
         
        {
             
            System.out.println("in finally");
         
        }
     
    }
 
}

运行结果：

finally不会每次都执行，例如以上程序，当执行完throw new Exception("Exception is thrown in main");语句后便关闭了程序，System.exit(0)可以终止程序。

5.如何跟踪异常的传播路径？

当程序中出现异常时，JVM会依据方法调用顺序依次查找有关的错误处理程序。

可使用printStackTrace 和 getMessage方法了解异常发生的情况：

printStackTrace：打印方法调用堆栈。

每个Throwable类的对象都有一个getMessage方法，它返回一个字串，这个字串是在Exception构造函数中传入的，通常让这一字串包含特定异常的相关信息。

请通过 PrintExpressionStack.java示例掌握上述内容。

// UsingExceptions.java
// Demonstrating the getMessage and printStackTrace
// methods inherited into all exception classes.
public class PrintExceptionStack 
{
   public static void main( String args[] )
   {
      try 
      {
         method1();
      }
      catch ( Exception e ) 
      {
         System.err.println( e.getMessage() + "\n" );
         e.printStackTrace();
      }
   }

   public static void method1() throws Exception
   {
      method2();
   }

   public static void method2() throws Exception
   {
      method3();
   }

   public static void method3() throws Exception
   {
      throw new Exception( "Exception thrown in method3" );
   }
}

运行结果：

6.依据对本讲多个示例程序的分析，请自行归纳总结出Java多层嵌套异常处理的基本流程。

阅读任何一本Java教材，或者是使用互联网搜索引擎，查找有关Java多层嵌套异常处理流程的资料，看看你总结得是否全面。

7.请看以下代码，它们完全符合Java语法规范，但事实是它们不能通过编译：

public class TestThrows {

public static void main(String[] args) {

FileInputStream fis = new FileInputStream("a.txt");

}

修正代码

public class TestThrows {

public static void main(String[] args)

throws FileNotFoundException（受控的异常）

{

FileInputStream fis = new FileInputStream("a.txt");

}

解释：

throws语句表明某方法中可能出现某种（或多种）异常，但它自己不能处理这些异常，而需要由调用者来处理。

当一个方法包含throws子句时，需要在调用此方法的代码中使用try/catch/finally进行捕获，或者是重新对其进行声明，否则编译时报错。

受控与不受控的异常：

throws语句中声明的异常称为受控（checked）的异常，通常直接派生自Exception类。

RuntimeException（其基类为Exception）和Error（基类为Throwable）称为非受控的异常。这种异常不用在throws语句中声明。

CheckedExceptionDemo.java示例展示了上述两种异常的特性。

8.抛出多个受控异常的方法

一个方法可以声明抛出多个异常

int g(float h) throws OneException,TwoException

{ …… }

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(); 
    } 
}

运行结果：

注意一个Java异常处理中的一个比较独特的地方：

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

9.子类抛出受控异常的限制

一个子类的throws子句抛出的异常，不能是其基类同名方法抛出的异常对象的父类。

OverrideThrows.java示例展示了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
    {
            //...
    }
}

10.Java 7 中的新特性

Java 7 及以后的版本，允许在一个catch块中捕获多个异常。

示例代码如下：

try {
            //...
            throw new SocketException();
    }
    catch (SocketException | SecurityException | NullPointerException e) {
            //exception handler
    }

11.关于开发中异常处理的建议

（1）在中间层组件中抛出异常，在界面层组件中捕获异常在底层组件中捕获JVM抛出的“只有程序员能看懂的”异常，转换为中间层的业务逻辑异常，再由界面层捕获以提供有意义的信息。

自身能够处理的异常，不要再向外界抛出。

尽可能地在靠近异常发生的地方捕获并处理异常。

（2）尽可能地捕获最具体的异常类型，不要在中间层用 catch(Exception)“吃掉”所有异常

在开发阶段捕获并显示所有异常信息，发布阶段要移除部分代码，以避免“过于专业”的异常信息困扰用户，特别地，系统发布之后，不要将服务端异常的详细信息发给客户端，以免被黑客利用。

12.编写一个程序，此程序在运行时要求用户输入一个整数，代表某门课的考试成绩，程序接着给出“不及格”、“及格”、“中”、“良”、“优”的结论。

package Test;
import java.util.InputMismatchException;
import java.util.Scanner;
public class dengji {
 
    public static void main(String[] args) {
         
        Scanner scanner=new Scanner(System.in);
        int n=-1;
        try {
            System.out.print("请输入一个范围为0~100的整数:");
            n=scanner.nextInt();
            if(0<=n&&n<60){
                System.out.println("不及格");
            }
            if(60<=n&&n<80) {
                System.out.println("中");
            }
            if(80<=n&&n<90) {
                System.out.println("良");
            }
            if(90<=n&&n<=100) {
                System.out.println("优");
            }
            if(n<0||n>100) {
               System.out.println("输入超出范围！");
            }
        }
        catch (InputMismatchException e) 
        {
            System.out.println("输入不是整数");
        }
 
    }
 
}