PPT动手动脑5

1.

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

程序报如下错误：

当我们将try外面的i/j注释掉运行结果变成如下：

再将try里面的i/j注释掉，将throw new Exception("Hello.Exception!")；的注释解除得到：

我们可以得到java对于异常处理的一些基础知识：

1.java通过try...catch实现对于异常的处理，如果没有try..catchjava虚拟机将退出。

2.不管异常是否出现finally的语句一定会被执行。

3.当有多个catch时java会从上到下匹配，找到后执行catch中的语句，且之后的catch不会被执行。

2.

duoble类型的运行结果：

其实由此可以看出浮点型与整型的计算原理是不一样的。

浮点型中引入了无限的概念：

System.out.println((1.0 / 0)); // Infinity
        System.out.println((-1.0 / 0)); // -Infinity
        System.out.println((1.0 / 0.0) * 0);// NAN
        System.out.println(0.0d / 0.0); // NAN
        System.out.println((1.0 / 0) == (1.0 / 0));// true

所以输出了Infinity而不会报错。

3.

下面为运行结果：

 内层的try抛出了Array...这个错误，在内层的catch中匹配到，所以输出了内层的语句而不会输出外层的。

外层的try抛出了Arithmetic..这个错误外层第一个catch匹配，所以得到了以上结果。

以下为运行结果：

 内层的try抛出了Array...的异常但是内层的没有与之配对的catch，所以它向外层寻找，并最终执行了外层的Array的catch。

而且我们发现外层try的ArithmenticException并没有抛出。

综上两个实例我们可以总结出java多层异常捕获的规律：

1.内层try的异常不仅仅会在内层寻找与之配对的catch，也会在外层寻找。

2.内层抛出了异常如果与之匹配的catch实在外层的则外层的异常并不会抛出。

4.

以下为代码：

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

以下为运行结果：

 

 看起来并不难理解，第三层出错，第三层的catch捕获而且finally被执行，单要注意1,2层的finally也执行了。

我们将三层加上注释，把二层的注释（第三层try之前）去掉观察运行结果：

 我们发现二层的catch捕获了异常，1,2层的finally执行，而第三层的没有执行。

我们将第二层中第三层try之后的注释去掉观察运行结果：

我们发现1,2,3层的finally都执行了但是第三层的finally在第二层抛出错误之前。

 那我们不难猜测出第一层try去掉注释后的结果：

 我们可以总结得到：

嵌套的finally是否执行取决于出错的位置：若最内层出错，则毫无疑问所有的finally都会执行。

若在外层出错：由于语句会从上到下执行，若外层出错位置在内层finally之后则会执行内层的finally否则不会执行（不管内层有没有错误）。

5.

以下为代码：

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

以下为运行结果：

 由于catch中有exit（0）所以finally不执行。

但是有一个有趣的现象，将//System.exit(0);的注释去掉，会报错，担当把它移到throw new Exception之前就不会报错了。