java之异常处理

AboutException的测试：

package test;
import javax.swing.*;

class AboutException {
   public static void main(String[] a) 
   {
      @SuppressWarnings("unused")
    int i=1, j=0, k;
      //System.out.println("第一次直接对两个整数进行除法运算结果：");
      //k=i/j;


    try
    {
        System.out.println("第五次测试finally语句在没有报错的前提下以及提前退出语句下是否会被执行：");
         //System.out.println("第二次将两个整数放在try{}catch{}函数中进行除法运算结果：");
        k = i/j;    // Causes division-by-zero exception
        //throw new Exception("Hello.Exception!");
        //System.out.println("第三次测试finally语句在没有报错的情况下是否会被执行：");
        
    }
    

    
    catch (Exception e)
    {
        
            System.out.println(e.getMessage());
            System.exit(0);
        
    }

    
    finally
     {
             JOptionPane.showConfirmDialog(null,"OK");
     }
        
  }
}

1.第一次

 

因为0不能作为分母而报错。

第二次

 

可以看到在try{}catch{}函数中虽然没有报错，但运算结果是将报错信息输出：/ by zero，

可以看出try{} catch{}函数的作用，还可以看到错误的信息。

第三次

可以看到，在程序没有报错的情况下，finally任然会被执行。

第四次

 

可以看到，在报错的前提下，加入提前退出语句后只输出了错误信息，而没有执行finally语句。

第五次

 

可以看到，在没有报错的前提下，catch语句不能正常执行，所以提前退出语句不执行，finally语句得以正常执行。

综上所述，有

（1）Finally语句不管有没有异常发生，finally语句都得以运行，但是在遇到提前退出语句后不能被执行。

（2）try{}catch{}函数能将错误信息抛出.

ThrowDemo的测试：

package test;
public class ThrowDemo { 
    public static void main(String[] args) { 
//        try {
            double data = 100 / 0.0;
            System.out.println("浮点数除以零：" + data); 
//            if(String.valueOf(data).equals("Infinity"))
//            { 
//                System.out.println("In Here" ); 
//                throw new ArithmeticException("除零异常");
//            }
//        } 
//        catch(ArithmeticException e) { 
//            System.out.println(e); 
//        } 
    } 
}
 

1.第一次测试

没有报错，但是如果将0.0改为0就会有如下结果：

这个错误相比不是很陌生了，因为在上一个测试中我们遇到了无数次这个错误类型，就是因为分母为零，根据Java对double的定义运算，结果为无限。

2.第二次测试

系统抛出新的错误被截取，

3.第三次测试

　　

错误被截取后正常输出。

在这个测试里，第二个catch没有被编译执行。

CatchWho测试：

package test;
public class CatchWho { 
    public static void main(String[] args) { 
        try { //2
                try { //1
                    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) { //没有输出，因为前面有一个catch将错误捕捉，这个就不会被执行了
           System.out.println(  "ArrayIndexOutOfBoundsException" + "/外层try-catch"); 
        } 
    } 
}

测试结果

 抛出错误类型。

CatchWho2测试：

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

EmbededFinally测试;

package test;
public class EmbededFinally {

    
    public static void main(String args[]) {
        
        int result;
        
        try {
            //result=100/0;
            System.out.println("in Level 1");

           
             try {
                 result=100/0;
                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");
        
        }
    
    }

}

测试结果：

 总结：

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