动手动脑6——异常处理

1.运行下面两端代码，观察结果:

第1段：

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

第2段:

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

两端代码区别就在一句，但是结果并不一样:

这是第1段代码:

这是第二段代码运行结果:

结果相差很大，原因很简单，代码1中，第一次出现的 k = i / j 这句被注释掉了，所以在第二次 k = i / j 才会抛出异常，而且这个异常有catch语句来捕捉，后面还有个finally语句来输出个消息面板。而如果不加注释，也就是第二段代码，第一次出现k = i / j就会发生异常(也就是不能除0那个)，由于没有捕捉机制的设置，所以JVM会自动显示异常信息(当然并不是中文啦。。)，并且会结束程序。

2.阅读下面的代码，分析结果:

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

由于实在内层发生的异常，内层的catch语句捕捉后直接处理掉

3.修改了上面的代码，分析下面的结果:

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

由于在内层的try中没有对ArrayIndexOutOfBoundsException这类异常进行处理的语句，所以这个异常会被抛出，而外层catch语句可以捕捉这类异常，所以最后输出结果会显示外层那一堆。

3.运行下面的代码，分析结果:

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

}

这个例子比较简单，整形除0抛出异常被捕捉，输出字符串形式的异常信息，该执行的finally块中的语句正常执行

4.finally语句一定会执行吗?当然不一定，如果catch捕捉异常之后执行了System.exit(0)这类结束程序的语句，finally自然不会执行。

比如下面这个例子:

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


}

结果显然易见，in finally 是不会被输出的

5.关于跟踪异常的传播路径:

以下代码仅供参考:

// 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() + "
" );
         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.一个抛出多个所谓“受控异常”的例子":

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

运行结果:

7.子类抛出受控异常的限制:一个子类的throws子句抛出的异常，不能是其基类同名方法抛出的异常对象的父类。

下面的这个例子可以说明这个问题:

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
    {
            //...
    }
}

注释上给出了具体说明。

8.最后我也来写一个简单的例子吧:

编写一个程序，此程序在运行时要求用户输入一个 整数，代表某门课的考试成绩，程序接着给出“不及格”、“及格”、“中”、“良”、“优”的结论。
要求程序必须具备足够的健壮性，不管用户输入什 么样的内容，都不会崩溃。

代码如下:

import java.util.InputMismatchException;
import java.util.Scanner;

public class Test {
      @SuppressWarnings("resource")
    public static void main(String[]a) {
          int num = 0;
          Scanner input = new Scanner(System.in);
         
              try {
                  System.out.print("输入数学分数:");
                  num = input.nextInt();      
                  if(num<0||num>100)throw new NumberFormatException();
              }
              catch(NumberFormatException e) {
                  //如果输入的是越界数字,直接抛出这个格式异常
                  System.out.println("输入有误!");
                  input.close();
                  System.exit(-1);
              }
              catch(InputMismatchException e) {
                  //如果输入的不是整形,而是double或者String等类型,会直接抛出这个异常
                  System.out.println("输入有误!");
                  input.close();
                  System.exit(-1);
              }
          if(num<60)System.out.println("数学不及格");
          else if(num>=60&&num<=69)System.out.println("数学及格");
          else if(num>=70&&num<=79)System.out.println("数学中等");
          else if(num>=80&&num<=89)System.out.println("数学良好");
          else if(num>=90&&num<=99)System.out.println("数学优秀");
          else System.out.println("数学满分");
          input.close();
      }
}

附上几次验证结果:

输入字符串(字符):

输入小数:

输入越界数字(小于0或者大于100):

最后小小的骄傲一下(P.S.:我数学确实还可以的说。。。):

----------------------------------------------------------------------------------------------

END