程序博客网 > 网络作家富豪榜2017

java异常捕捉陷阱（内存泄漏，finally块，catch块，继承得到的异常）

来源：互联网 发布：网络作家富豪榜2017 编辑：程序博客网 时间：2024/05/16 09:43

    

目录(?)[+]

  1. 异常捕捉的陷阱
    1. 正确关闭资源的方式
    2. finally块的陷阱
    3. catch块的用法
      1. catch的顺序
      2. 不要用catch代替流程控制
      3. 只能catch可能抛出的异常
      4. 实际的修复
    4. 继承得到的异常
 
 
1.    异常捕捉的陷阱
    异常处理机制是java语言的特色之一，尤其是java语言的Checked异常，更是体现了java语言的严谨性：没有完善错误处理的代码根本不会被执行。对于Checked异常，java程序要么声明抛出，要么使用try……catch进行捕获。
1.1  正确关闭资源的方式
    在实际开发中，经常需要在程序中打开一些物理资源，如数据库连接，网络连接，磁盘文件等，打开这些物理资源之后必须显示关闭，否则将会导致资源泄漏。因为垃圾回收机制属于java内存管理的一部分，它只是负责会受堆内存中分配出来的内存，至于程序中打开的物理资源，垃圾回收机制是无能为力的。
    为了正常关闭程序中打开的物理资源，应该使用finally块来保证回收。比如下面三种关闭资源的方式，哪种更好些？
[java] view plaincopyprint?
  1. public static void main(String args[]) throws Exception {  
  2.                    Student student_new = new Student("liyafang");  
  3.                    Student student_recover = null;  
  4.                    ObjectOutputStream oos = null;  
  5.                    ObjectInputStream ois = null;  
  6.                    try {  
  7.                             oos = new ObjectOutputStream(new FileOutputStream("liyafang.txt"));  
  8.                             ois = new ObjectInputStream(new FileInputStream("liyafang.txt"));  
  9.                             oos.writeObject(student_new);  
  10.                             oos.flush();  
  11.                             student_recover = (Student) ois.readObject();  
  12.                             System.out.println(student_recover.equals(student_new));  
  13.                             System.out.println(student_recover == student_new);  
  14.                    } finally {  
  15. //1.第一种关闭资源的方式（不够安全）：程序刚开始指定oos = null；ois = null；完全有可能在程序运行过程中初始化oos之前就引发了异常，那么oos，ois还没有来得及初始化，因此oos，ois根本无需关闭。  
  16.                             oos.close();  
  17.                             ois.close();  
  18. //2.第二种关闭资源的方式（还是不够安全）：假如程序开始已经正常初始化了oos，ois两个IO流，在关闭oos是出现了异常，那么程序将在关闭oos时非正常退出，这样就导致ois得不到关闭，从而导致资源泄漏。为了保证关闭各资源时出现的异常不会相互影响，应该在关闭每个资源时分开使用try catch块来保证关闭操作不会导致程序非正常退出。  
  19.                             if(oos != null){  
  20.                                      oos.close();  
  21.                             }  
  22.                             if(ois != null){  
  23.                                      ois.close();  
  24.                             }  
  25. //3.第三种关闭资源的方式（比较安全）：主要保证一下几点：  
  26. //（1）使用finally块来关闭物理资源，保证关闭操作始终会被执行；  
  27. //（2）关闭每个资源之前首先保证引用该资源的引用变量不为null；  
  28. //（3）为每个物理资源使用单独的trycatch块关闭资源，保证关闭资源时引发的异常不会影响其他资源的关闭。  
  29.                             if(oos != null){  
  30.                                      try{  
  31.                                                oos.close();  
  32.                                      }catch (Exception ex){  
  33.                                                ex.printStackTrace();  
  34.                                      }  
  35.                             }  
  36.                             if(ois != null){  
  37.                                      try{  
  38.                                                ois.close();  
  39.                                      }catch (Exception ex){  
  40.                                                ex.printStackTrace();  
  41.                                      }  
  42.                             }                 }  
  43.          }  

1.2  finally块的陷阱
    当程序在finally之前使用System.exit(0),finally将不执行。调用System.exit(0)将使JVM退出，只要JVM不退出，finally就一定会得到执行。
    在java程序执行try块、catch块时遇到了return语句，return语句会导致该方法立即结束。系统执行完return语句之后，并不会立即结束该方法，而是去寻找该异常处理流程中是否包含Finally块，如果没有Finally块，方法终止，返回相应的返回值。如果有Finally块，系统立即开始执行Finally块，只有当Finally执行完成后，系统才会再次跳回来根据return语句结束方法。如果Finally块使用了return语句来导致方法的结束，则finally块已经结束了方法，系统不会跳回去执行trycatch里的任何代码。
[java] view plaincopyprint?
  1. public int test(){  
  2.                    int count = 1;  
  3.                    try{  
  4.                             return ++count;  
  5.                    }finally{  
  6.                             return ++count;  
  7.                    }  
  8.          }  
  9. //以上代码最终返回值是：3  
  10. public int test(){  
  11.                    int count = 1;  
  12.                    try{  
  13.                             return ++count;  
  14.                    }finally{  
  15.                             return count++;  
  16.                    }  
  17.          }  
  18. //以上代码最终返回值是：2  


throw语句的执行和return语句比较类似。当程序执行trycatch块遇到throw语句时，throw语句会导致该方法立即结束，系统执行throw语句时并不会立即抛出异常，而是去寻找该异常处理流程中是否包含finally块。如果没有finally块，程序立即抛出异常。如果有finally块，系统立即执行finally块，只有当finally块执行完成之后，系统才会再次跳出来抛出异常。如果finally块里使用return语句来结束方法，系统将不会跳回去执行try块，catch块去抛出异常。
例如1：
[java] view plaincopyprint?
  1. int count = 1;  
  2.                    try{  
  3.                             throw new RuntimeException("异常1");  
  4.                    }finally{  
  5.                             return count++;  
  6.                    }  
  7. //执行结果：返回值是1，同时不会抛出任何异常。  


例如2：
[java] view plaincopyprint?
  1. int count = 1;  
  2.                    try{  
  3.                             throw new RuntimeException("异常1");  
  4.                    }finally{  
  5.                             throw new RuntimeException("异常2");  
  6.                    }  
  7. //执行结果：Exception in thread "main" java.lang.RuntimeException: 异常2  


1.3  catch块的用法
1.3.1 catch的顺序
    对于java的异常捕获来说，每个try块至少需要一个catch块或一个finally块，绝不能只有单独一个孤零零try块。通常情况下，如果try块被执行一次，则try块后只有一个catch块会被执行，绝不可能有多个catch块被执行。除非在循环中使用了continue开始下一次循环，下一次循环又重新运行了try块，才可能导致多个catch块被执行。由于异常处理机制中排在前面的catch(XxxException ex)块总是会优先获得执行的机会，因此java对try块后的多个catch块的排列顺序是有要求的。
   因为java的异常有非常严格的继承体系，许多异常类之间有严格的父子关系，比如程序FileNotFoundException异常就是IOException的子类。捕获父类异常的catch块都应该排在捕捉子类异常的catch块之后【先处理小异常（子类异常），在处理大异常（父类异常）】，否则将出现编译错误。
         例如以下两个catch语句不能颠倒顺序：
                 
[java] view plaincopyprint?
  1. FileInputStream fis = null;  
  2.                   try{  
  3.                            fis = new FileInputStream("a.bin");  
  4.                            fis.read();  
  5.                   }catch(FileNotFoundException ex){  
  6.                            ex.printStackTrace();  
  7.                   }catch(IOException e){  
  8.                            e.printStackTrace();  
  9.                   }  

1.3.2不要用catch代替流程控制
如下边这个例子：
[java] view plaincopyprint?
  1. String[] students = {"liyafang","zhoushilong","luorongbo"};  
  2.                    int i = 0;  
  3.                    while(true){  
  4.                             try{  
  5.                                      System.out.println(students[i++]);  
  6.                             }catch(IndexOutOfBoundsException ex){  
  7.                                      break;  
  8.                             }  
  9.                    }  


这种遍历数组的方式不仅难以阅读，而且运行速度还非常慢。
千万不要使用异常来进行流程控制。异常机制不是为流程控制而准备的，异常机制知识为程序的意外情况准备的，因此程序只应该为异常情况使用异常机制。所以，不要使用这种“别出心裁”的方法来遍历数组。
1.3.3只能catch可能抛出的异常
[java] view plaincopyprint?
  1. /*public static void test1(){ 
  2.                try{ 
  3.                         System.out.println("something"); 
  4.                }catch(IOException e){ 
  5.                         e.printStackTrace(); 
  6.                } 
  7.      } 
  8.      public static void test2(){ 
  9.                try{ 
  10.                         System.out.println("something"); 
  11.                }catch(ClassNotFoundException e){ 
  12.                         e.printStackTrace(); 
  13.                } 
  14.      }*/  


以上代码java编译器是不允许的。
根据java语言规范，如果一个catch子句试图捕获一个类型为XxxException的Checked异常时，那么它对应的try子句必须可能抛出XxxException或其子类的异常，否则编译器将提示该程序具有编译错误—但在所有的Checked异常中，Exception是一个异类，无论try块是怎样的代码，catch(Exception e)总是正确的。
RuntimeException 类及其子类的实例被称为Runtime异常，不是RuntimeException类及其子类的异常实例则被称为Checked异常，只要愿意，程序员总可以使用catch(XxxException ex)来捕获运行时异常。
总之，程序使用catch捕捉异常时，其实并不能随心所欲地捕捉所有异常。程序可以在任意想捕捉的地方捕捉RuntimeException异常，Exception，但对于其他的Checked异常，只有当try块可能抛出该异常时（try块中调用的某个方法声明抛出了该Checked异常），catch块才捕捉该Checked异常。
 1.3.4实际的修复
如果程序知道如何修复指定异常，应该在catch块内尽量修复该异常，当该异常情况被修复后可以再次调用该方法；如果程序不知道如何修复该异常，也没有进行任何修复，千万不要再次调用可能导致该异常的方法。
无论如何不要在finally块中递归调用可能引起异常的方法，因为这将导致该方法的异常不能被正常抛出，甚至StackOverflowError错误也不能中止程序，只能采用强行结束java.exe进程的方法来中止程序的运行。
1.4  继承得到的异常
Java语言规定：子类重写父类的方法时，不能声明抛出比父类方法类型更多，范围更大的异常。也就是说，子类重写父类方法时，子类方法只能声明抛出父类方法所声明抛出的异常的子类。
例如：
[java] view plaincopyprint?
  1. public interface Type1 {  
  2.          void test() throws ClassNotFoundException;  
  3. }  
  4. public interface Type2 {  
  5.          void test() throws NoSuchMethodException;  
  6. }  
  7. class Test implements Type1, Type2 {  
  8.          @Override  
  9.          public void test() {  
  10.          }  
  11. }  


上面代码的异常处理是正确的。
Test实现了Type1接口，实现Type1接口里的test()方法时可以声明抛出ClassNotFoundException异常或该异常的子类，或者不声明抛出；Test类实现了Type2接口，实现了Type2接口里的test()方法时可以声明抛出NoSuchMethodException异常或该异常的子类，或者不声明抛出。由于Test类同时实现了Type1，Type2两个接口，因此需要同时实现两个接口中的test()方法。只能是上面两种声明抛出的交集，不能声明抛出任何异常。
0 0
网络作家富豪榜2017 网络作家富豪榜2017
原创粉丝点击
热门IT博客
梦幻手游mac版双开梦幻手游mac版双开
淘宝设置提醒在哪里看淘宝设置提醒在哪里看
apache用户访问认证
ubuntu如何安装deb包
tftp文件传输端口号
java连接池如何选择
ubuntu 16.04 ip设置
淘宝货品上架品牌申请
炒股模拟软件
手机sim卡数据恢复
数据库管理应用与开发
阿里云怎么发短信
js中如何遍历数组
教务网络管理系统
ubuntu 输入法 安装
免费足球缩水软件
淘宝茜茜家的铺子真假
手机淘宝返现怎么操作
防火知多少课后反思
买到淘宝假货怎么投诉
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 机锋二手手机交易市场 古玩人生 机锋 机锋app下载手机版 机锋手游平台app 机锋应用商店 机锋市场客户端 机锋软件市场 三星论坛 安卓手机论坛 机峰论坛 机峰 机用丝锥价格 全自动锥度缩管机 双锥混合机 弧齿锥齿轮铣齿机 锥度热转印机 二手双锥干燥机 双锥混料机 锥型破碎机 锥式破碎机 锥破碎机 螺旋锥齿轮减速机 机长 刘传建机长 机长观后感 刘长建机长 机长英文 中国机长还原度获赞 中国机长真实事件 中国机长观后感 中国机长免费观看 中国机长在线播放 中国机长完整观看超清版 中国机长在线 中国机长观看 中国机长群演 中国机长什么时候上映 中国机长还原度 中国机长免费 中国机长抢先观看 龙工装载机

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