• private static void foo() {      
•         try {      
•             System.out.println("try");      
•             foo();      
•         } catch (Throwable e) {      
•             System.out.println("catch");      
•             foo();      
•         } finally {      
•             System.out.println("finally");      
•             foo();      
•         }      
•     }      
•          
•     public static void main(String[] args) {      
•         foo();      
•     }   
  

结果是这样的： 无限循环！！！

不太懂，希望指点一下！

如果没有异常，先执行try再执行finally，每次try和finally里都调用foo()方法，所以无限调用这个方法

梁小波 发表于 2012-7-18 19:00
不是不显示是显示太快。你应该是eclipse吧，你可以单步执行一下！就会看到结果了，或者去掉finally块，虽 ...

哦哦，这样呀，我用的MyEclipse，我试一下。大师呀:handshake

高欢欢 发表于 2012-7-18 18:46
“首先运行的结果不会是一开始就tryfinallyfinally这样！
而是必定为trytrytry。。。。下去！”  不太懂 ...

不是不显示是显示太快。你应该是eclipse吧，你可以单步执行一下！就会看到结果了，或者去掉finally块，虽然会报错，但栈溢出前的结果是正确的；你就会发现都是try

梁小波 发表于 2012-7-18 17:50
这个问题远不是我们想的那样！楼上几位的回答也绝非正解！
首先运行的结果不会是一开始就tryfinallyfinally ...

“首先运行的结果不会是一开始就tryfinallyfinally这样！
而是必定为trytrytry。。。。下去！”  不太懂，那为啥运行结果不显示呢？
现在更晕了！

1. private static long count=0;
   
2.         private static int foo() {      
   
3.                 try {      
   
4.                     System.out.println("try");  
   
5.                     count++;
   
6.                     foo();      
   
7.                 } catch (Throwable e) {      
   
8.                     System.out.println("catch");      
   
9.                     foo();      
   
10.                 }
    
11.                  finally {  
    
12.                         return 1;
    
13.                     //System.out.println("finally");      
    
14.                    // foo();      
    
15.                 }
    
16.             }      
    
17.                 
    
18.             public static void main(String[] args) {      
    
19.                 foo();   
    
20.                 System.out.println(count);
    
21.             }   
    
22. }
    

复制代码

贴子要沉了！我要顶上去！这个问题真的不是很容易啊！
做了一下测试！
按照以上代码。首先try一般会到5100多次会停止也就是count会是5100多的数字；不定，我认为是jvm决定的。每个人可能不一样；
这时会发生异常Exception in thread "main" java.lang.StackOverflowError；我怎么得到的呢。你去掉finally块就会显示了！
之所以之前没有显示的原因是由于这是一个error！我们由于有finally块结果必须要执行finally快的内容；于是又执行到了foo（）函数；
但是栈已经溢出了！所以会执行的步骤会有点乱！确实我的水平有限，就可以分析到这了；
我觉得下面会是jvm怎么处理栈的内存。可能会清理一些？继续测试。。。
我感觉大家都来测试一下这个demo会很有用的！

5楼说对

这个问题远不是我们想的那样！楼上几位的回答也绝非正解！
首先运行的结果不会是一开始就tryfinallyfinally这样！
而是必定为trytrytry。。。。下去！
直到出现异常！为什么会有异常？因为内存有限；无限递归必定会异常！
所以大家好好想一下这个demo，没有那么简单！
继续测试。。。

蒋映辉 发表于 2012-7-18 17:22
private static void foo() {      
        try {      
            System.out.println("try");      

哦，没说太明白！想知道这个结果的为什么出现的这样的顺序！

1. public class Test1 {
   
2.         private static void foo() {
   
3.                         try{
   
4.                                 foo();
   
5.                         }catch(Exception e){
   
6.                                 foo();
   
7.                         }finally{
   
8.                                 foo();
   
9.                         }
   
10.         }      
    
11. }
    

复制代码

我不明白这样写的目的。楼主是想什么时候执行try中的语句，什么时候执行catch中的语句，什么时候执行finally中的语句吗？

java中写在try中的语句如果遇到了异常。它会在catch中捕获到异常，然后将执行catch中的语句，将异常打印出来，再执行finally 中的语句，楼主在try中写的语句没有遇到异常，所以不会执行catch中的语句，而只会执行finlly中的语句，所以只会打印try和finlly。try和catch中的语句不管出现什么情况，finally中的都会执行，除非你使用了System.exit(0);让虚拟机直接退出。比如说：

1. public class Test1 {
   
2.         private static void foo() {
   
3.                         try{
   
4.                                 System.out.println("try");
   
5.                                 System.exit(0);
   
6.                         }catch(Exception e){
   
7.                                 System.out.println("catch");
   
8.                         }finally{
   
9.                                 System.out.println("finally");
   
10.                         }
    
11.         }     
    
12.        
    
13.         public static void main(String agrsp[]){
    
14.                 foo();
    
15.         }
    
16. }

复制代码

这样就不会执行finally中的语句。楼主现在的代码就是一个递归而没有添加任何判断条件的递归，所以就是一个无限循环

try在进行调用finally中也在进行调用，肯定无限循环

private static void foo() {      
        try {      
            System.out.println("try");      
            foo();   
你这是在做什么？不就是一直在调用这个函数么，无限次调用  肯定就无限循环了撒