标签：arrays warnings 调试 not open dex close 结果 lse
finally语句什么时候用：
你没必要在finally语句里处理内存回收，因为内存回收会由垃圾回收器完成，finally语句通常用于内存回收之外的情况。当要把除内存之外的资源恢复到它们初始状态时，就要用到finally子句。这种需要清理的资源包括：已经打开的文件或网络连接，在屏幕上画的图形，甚至外部世界的某个开关。
package 异常.Finally; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class Fin { public static void main(String[] args) { test(); } public static void test() { File file = null; FileInputStream in = null; file = new File("C:/Users/admin/Desktop/12.xls"); try { in = new FileInputStream(file); System.out.println("打开成功！"); }catch(FileNotFoundException e) { System.out.println("创建File对象时，未找到指定文件，此时文件流构造失败，并未被打开！"); e.printStackTrace(); }catch(Exception e){ System.out.println("任何其他捕获异常的catch块子句必须关闭文件"); System.out.println("因为在他们捕获到异常之时，文件已经打开了"); try { if(in != null) { in.close(); } } catch (IOException ie) { e.printStackTrace(); } }finally { //不能在这里关闭流，因为流从未被打开过 } } }
控制台：
创建File对象时，未找到指定文件，此时文件流还未被打开！ java.io.FileNotFoundException: C:\Users\admin\Desktop\12.xls (系统找不到指定的文件。) at java.io.FileInputStream.open0(Native Method) at java.io.FileInputStream.open(Unknown Source) at java.io.FileInputStream.<init>(Unknown Source) at 异常.Finally.Fin.test(Fin.java:20) at 异常.Finally.Fin.main(Fin.java:11)
finally语句怎么用才恰当：
对于在构造阶段可能会抛出的异常，并且要求清理的类，最安全的使用方式是使用嵌套的try子句
更恰当的写法：
package 异常.Finally; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; public class Fin { public static void main(String[] args) { test(); } public static void test() { File file = null; BufferedReader bf = null; file = new File("C:/Users/admin/Desktop/new 1.txt"); try { bf = new BufferedReader(new FileReader(file)); try { while(bf.readLine() != null) { System.out.println(bf.readLine()); } }catch(Exception e) { e.printStackTrace(); }finally { if(bf!=null) { bf.close(); } } }catch(Exception e) { System.out.println("FileInputStream对象构造失败"); } } }
只有在流构建成功时，才要去保证流对象被清理。使用嵌套的基本规则就是：在创建需要清理的对象之后，立即进入下一个try-finally语句块。
finally语句不受break与continue影响：
package 异常.Finally; public class FinallyTest { static void test() { int i = 0; while(true) { try { if(i < 1) { i++; continue; }else { break; } }catch(Exception e) { e.printStackTrace(); }finally { System.out.println("我不受break/continue影响！"); } } } public static void main(String[] args) { test(); } }
控制台：
我不受break/continue影响！
我不受break/continue影响！
在return中使用finally：
1 package 异常.Finally; 2 3 public class FinallyTest { 4 5 static int test() { 6 int i = 0; 7 try { 8 return i++; 9 }catch(Exception e) { 10 e.printStackTrace(); 11 }finally { 12 System.out.println("我不受return影响！"); 13 } 14 return 10; 15 } 16 17 public static void main(String[] args) { 18 System.out.println(test()); 19 } 20 21 }
控制台：
我不受return影响！
0
看以看出finally被执行了。return即代表程序结束，但finally却被执行了，可以说明finally语句块肯定是在return之前执行的。但经过断点调试（断点位置：6 ，8 ，12），我却发现以上断定是错误的，程序是先执行了6，然后执行了8，在之后才执行12，最后又执行了8。感觉好像return专门给finally开了一个小灶，在return之前先执行一下finally语句，然后就直接return结束程序。
finally与return到底有什么样的联系？
1 package 异常.Finally; 2 3 public class FinallyTest { 4 5 static int test() { 6 int i = 0; 7 try { 8 return i; 9 }catch(Exception e) { 10 e.printStackTrace(); 11 }finally { 12 i = i + 5; 13 System.out.println("我不受return影响！"); 14 } 15 return 10; 16 } 17 18 public static void main(String[] args) { 19 System.out.println(test()); 20 } 21 22 }
控制台：
我不受return影响！
0
断点位置依旧如上，再次调试，发生了不可思议的问题，当执行完finally之后，i 确实变为了5，而且在最后执行return时，此时鼠标放在 i 上也真真切切的是 i = 5；但是最后打印的结果还是 0 ！似乎return只记住了最开始的 i 值，之后对 i 的操作，都被无视了。
当把基本数据类型换为引用类型时：
package 异常.Finally; import java.util.Arrays; public class FinallyTest { static int[] test() { int[] i = {1,2,3}; try { return i; }catch(Exception e) { e.printStackTrace(); }finally { i[2] = 10; System.out.println("我不受return影响！"); } return null; } public static void main(String[] args) { System.out.println(Arrays.toString(test())); } }
控制台：
我不受return影响！
[1, 2, 10]
莫名的对于引用类型发生改变时，却没有被return无视。
基本类型是在栈中声明的，引用类型则在堆中。当return第一次发生时就应该把值或地址【当然地址也算是值】从栈中给弹出了，最后一次执行return时就直接使用最开始弹出的值或地址而不使用经finally改变后的，但由于引用类型是在堆中进行了操作，当最后拿着最初的地址去到堆里查找输出时，堆里的内容已经改变。地址的值和基本类型的值一样，二者都没有发生改变，只是堆内容改变了，再次寻找时，结果也变了，但是基本类型的值已经被弹出，并不受finally中的改变，所以还是原来的值。
finally里的return会层叠try或catch里的return：
1 package 异常.Finally; 2 3 4 public class FinallyTest { 5 6 @SuppressWarnings("finally") 7 static int test() { 8 int i = 1; 9 try { 10 return i; 11 }catch(Exception e) { 12 e.printStackTrace(); 13 }finally { 14 i = 5; 15 System.out.println("我不受return影响！"); 16 return i; 17 } 18 } 19 20 public static void main(String[] args) { 21 System.out.println(test()); 22 } 23 24 }
控制台：
我不受return影响！
5
debug后发现，并没有二次执行第10行，而是执行finally里的return后就结束了。似乎就是finally会层叠掉try或catch【已测试过】里的return。
学习thinking in java，结合网上各位大佬的观点，特此总结。
标签：arrays warnings 调试 not open dex close 结果 lse
原文地址：https://www.cnblogs.com/liudaihuablogs/p/9260338.html
