注册 登录
> Java

java解惑你知多少（四）

系统 1714 0

异常

26. finally与中断

Java代码     收藏代码
  1. //该方法返回false   
  2. static   boolean  f() {  
  3.   try  {  
  4.    return   true ;  
  5.  }  finally  {  
  6.    return   false ;  
  7.  }  
  8. }  

不要用return、break、continue或throw来退出finally语句块，并且千万不要允许受检查的异常传播到finally语句

块之外。也就是说不要在finally块内终止程序，而是执行完finally块后，要将控制权移交给try块，由try最终决定

怎样结束方法的调用。

 

对于任何在finally语句块中可能抛出的受检查异常都要进行处理，而不是任其传播，下面流拷贝程序在关闭流时没有

防止异常的传播，这会有问题：

Java代码     收藏代码
  1. static   void  copy(String src, String dest)  throws  IOException {  
  2.  InputStream in =  null ;  
  3.  OutputStream out =  null ;  
  4.   try  {  
  5.   in =  new  FileInputStream(src);  
  6.   out =  new  FileOutputStream(dest);  
  7.    byte [] buf =  new   byte [ 1024 ];  
  8.    int  n;  
  9.    while  ((n = in.read(buf)) >=  0 ) {  
  10.    out.write(buf,  0 , n);  
  11.   }  
  12.  }  finally {  
  13.    //这里应该使用try-catch将每个close包装起来   
  14.    if (in !=  null ){in.close();}  
  15.    if (in !=  null ){out.close();}  
  16.  }  
  17. }  

catch块中的return语句是不会阻止finally块执行的，那么catch块中的continue和break能否阻止？答案是不会的，

与return一样，finally语句块是在循环被跳过（continue）和中断（break）之前被执行的：

Java代码     收藏代码
  1. int  i =  0 ;  
  2. System.out.println( "--continue--" );  
  3. while  (i++ <=  1 ) {  
  4.   try  {  
  5.   System.out.println( "i="  + i);  
  6.    continue ;  
  7.  }  catch  (Exception e) {  
  8.  }  finally  {  
  9.   System.out.println( "finally" );  
  10.  }  
  11. }  
  12. System.out.println( "--break--" );  
  13. while  (i++ <=  3 ) {  
  14.   try  {  
  15.   System.out.println( "i="  + i);  
  16.    break ;  
  17.  }  catch  (Exception e) {  
  18.  }  finally  {  
  19.   System.out.println( "finally" );  
  20.  }  
  21. }  

27. catch捕获异常规则

捕获RuntimeException、Exception或Throwable的catch语句是合法，不管try块里是否抛出了这三个异常。但如果try

块没有抛出或不可能抛出检测性异常，则catch不能捕获这些异常，如IOException异常：

Java代码     收藏代码
  1. public   class  Test {  
  2.   public   static   void  main(String[] args) {  
  3.    try {  
  4.     //...   
  5.   } catch  (Exception e) {  
  6.      
  7.   } catch  (Throwable e) {  
  8.      
  9.   }  
  10.     
  11.    /* !! 编译出错  
  12.    try{  
  13.     //...  
  14.    }catch (IOException e) {  
  15.       
  16.    }  
  17.    */   
  18.  }  
  19. }  

28. 重写时方法异常范围

重写或实现时不能扩大异常的范围，如果是多继承，则异常取所有父类方法异常的交集或不抛出异常：

Java代码     收藏代码
  1. interface  I1 {  
  2.   void  f()  throws  Exception;  
  3. }  
  4.   
  5. interface  I2 {  
  6.   void  f()  throws  IOException;  
  7. }  
  8.   
  9. interface  I3  extends  I1, I2 {}  
  10.   
  11. class  Imp  implements  I3 {  
  12.   // 不能编译通过，多继承时只能取父类方法异常交集，这样就不会扩大异常范围   
  13.   // !! void f () throws Exception;   
  14.   // void f();// 能编译通过   
  15.   // 能编译通过，Exception与IOException的交集为IOException   
  16.   public   void  f()  throws  IOException {  
  17.  }  
  18. }  

29. 静态与非静态final常量不能在catch块中初始化

 

静态与非静态块中如果抛出了异常，则一定要使用try-catch块来捕获。

Java代码     收藏代码
  1. public   class  Test {  
  2.   static   final   int  i;  
  3.   static  {  
  4.    try  {  
  5.    i = f();  
  6.   }  catch  (RuntimeException e) {  
  7.    i =  1 ;  
  8.   }  
  9.  }  
  10.   
  11.   static   int  f() {  
  12.    throw   new  RuntimeException();  
  13.  }  
  14. }  

上面的程序编译不能通过。表面上是可以的，因为i第一次初始化时可能抛出异常，所以抛异常时可以在catch块中初

始化，最终还是只初始化一次，这正是空final所要求的，但为什么编译器不知道这些呢？

 

要确定一个程序是否不止一次地对一个空final进行赋值是很困难的问题。语言规范在这一点上采用了保守的方式。

30. System.exit()与finally

Java代码     收藏代码
  1. try  {  
  2.  System.out.println( "Hello world" );  
  3.  System.exit( 0 );  
  4.   // 或者使用Runtime退出系统   
  5.   // Runtime.getRuntime().exit(0);   
  6. }  finally  {  
  7.  System.out.println( "Goodbyte world" );  
  8. }  

上面的程序会打印出"Goodbyte world"吗？不会。

 

System.exit将立即停止所有的程序线程，它并不会使finally语句块得到调用，但是它在停止VM之前会执行关闭挂钩

操作（这此挂钩操作是注册到Runtime.addShutdownHook上的线程），这对于释放VM之外的资源很有帮助。使用挂钩程

序修改上面程序：

Java代码     收藏代码
  1. System.out.println( "Hello world" );  
  2. Runtime.getRuntime().addShutdownHook( new  Thread() {  
  3.   public   void  run() {  
  4.   System.out.println( "Goodbyte world" );  
  5.  }  
  6. });  
  7. System.exit( 0 );  

 

另外，对象回收时，使用VM调用对象的finalize()方法有两种：
System.runFinalization()：该方法让虚拟机也只是尽最大努力去完成所有未执行的finalize()终止方法，但不一定

会执行。
System.runFinalizersOnExit(true)：该方法一定会回收，但不安全，已被废弃。因为它可能对正在使用的对象调用

终结方法，而其他线程同时正在操作这些对象，从而导致不正确的行为或死锁。

 

为了加快垃圾回收，使用System.gc()，但不一定马上执行加收动作，由虚拟机决定，实质上是调用

Runtime.getRuntime().gc()。

 

System的很多方法都是调用Runtime类的相关方法来实现的。


31. 递归构造

Java代码     收藏代码
  1. public   class  S  {  
  2.   private  S instance =  new  S();  
  3.   public  S() {}  
  4. }  

如果在程序外面构造该类的实例，则会抛出java.lang.StackOverflowError错误。其原因是实例变量的初始化操作将

先于构造器的程序体而运行。


32. 构造器中的异常

如果父类构造器抛出了检测异常，则子类也只能抛出，而不能采用try-catch来捕获：

Java代码     收藏代码
  1. public   class  P {  
  2.   public  P()  throws  Exception {}  
  3. }  
  4.   
  5. class  S  extends  P {  
  6.   public  S()  throws  Exception {  
  7.    try  {  
  8.     // 不能在try块中明确调用父类构造器，因为构造的   
  9.     // 明确调用只能放在第一行   
  10.     // !! super();   
  11.    //try-catch不能捕获到父类构造器所抛出的异常，子类只能抛出   
  12.   }  catch  (Exception e) {  
  13.   }  
  14.  }  
  15. }  

 
如果初使化实例属性时抛出了异常，则构造器只能抛出异常，在构造器中捕获不起作用：

Java代码     收藏代码
  1. public   class  A {  
  2.      private  String str = String. class .newInstance();  
  3.   
  4.      public  A()  throws  InstantiationException, IllegalAccessException {}  
  5.   
  6.      public  A( int  i)  throws  Exception {  
  7.          try  { //即使这里捕获了，方法签名还是得要抛出   
  8.   
  9.         }  catch  (Exception e) {  
  10.   
  11.         }  
  12.     }  
  13.   
  14.      /*  
  15.      * !!编译不能通过，因为str2为静态的，他不能通过构造器来捕获，所以只  
  16.      * 能使用静态方法来捕获。即初始化静态成员时不能抛出捕获性异常。   
  17.      */   
  18.      //!!private static String str2 = String.class.newInstance();   
  19.       
  20.      // 只能使用静态方法来捕获异常，如果是抛出的运行时异常则不需要捕获   
  21.      private   static  String str2 = newInstance();  
  22.   
  23.      private   static  String newInstance()  throws  RuntimeException {  
  24.          try  {  
  25.              return  String. class .newInstance();  
  26.         }  catch  (Exception e) {  
  27.             e.printStackTrace();  
  28.         }  
  29.          return   null ;  
  30.     }  
  31. }  

33. StackOverflowError

Java虚拟机对栈的深度限制到了某个值，当超过这个值时，VM就抛出StackOverflowError。一般VM都将栈的深度限制

为1024，即当方法调用方法的层次超过1024时就会产生StackOverflowError。

java解惑你知多少（四）


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索：z360901061

微信扫一扫加我为好友

QQ号联系： 360901061

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧，狠狠点击下面给点支持吧，站长非常感激您！手机微信长按不能支付解决办法：请将微信支付二维码保存到相册，切换到微信，然后点击微信右上角扫一扫功能，选择支付二维码完成支付。

【本文对您有帮助就好】元

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧，站长会非常 感谢您的哦！！！

发表我的评论
最新评论 总共0条评论