程序博客网 > 难言之欲网络剧百度云

java解惑你知多少（四）

来源：互联网 发布：难言之欲网络剧百度云 编辑：程序博客网 时间：2024/04/27 22:34

异常

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。

难言之欲网络剧百度云 难言之欲网络剧百度云
原创粉丝点击
热门IT博客
apache tomcat 7.0使用apache tomcat 7.0使用
w7网络连接出现感叹号w7网络连接出现感叹号
java smtp ssl
平面设计的软件
国资委待遇怎么样知乎
淘宝818开学季
apache mime类型 json
软件静默安装器
数据库not exists用法
单机破解版进销存软件
美工30后就不能做了吗
linux 用户段错误
查看防火墙状态 linux
知错老师 闫春生
淘宝优惠劵是怎么回事
网络dj歌曲最红最好听
国内云计算服务提供商
姓名域名注册
喜当爹 知乎
识时务,知进退,善其身
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 空调冷风扇 美的冷风扇价格 蒸发式冷风扇 康佳冷风扇 冷风扇什么牌子好 冷风扇工作原理 冷风扇效果怎么样 奥克斯冷风扇说明书 美菱冷风扇 长城冷风扇 遥控冷风扇 海尔冷风扇 厨房 冷风扇 冷风扇 电风扇 工业冷风扇 电源风扇 吸风扇 离心式风扇 冷风暴全集 冷风暴演员表 冷风暴剧情介绍 电视连续剧冷风暴 冷风柜价格 冷风柜 冷风保鲜柜 生豆芽机 蒸馏器 大型豆芽机 华夫饼机 家用豆芽机 多功能面条机 冷餐包括什么 什么是冷餐 冷餐台 冷餐会方案 南京自助餐 什么是自助餐 加勒比自助餐 无锡自助餐 杭州自助餐 东莞自助餐

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里