1. public class smallT
   
2. {
   
3. public static void main(String args[])
   
4. {
   
5. smallT t = new smallT();
   
6. int b = t.get();
   
7. System.out.println(b);
   
8. }
   
9. 
   
10. public int get()
    
11. {
    
12. try
    
13. {
    
14. return 1 ;
    
15. }
    
16. finally
    
17. {
    
18. return 2 ;
    
19. }
    
20. }
    
21. }
    

复制代码

结果为什么是：2？？？郁闷 求解答

因为 finally 一定要执行的

只有一种情况不会执行，当执行到System.exit(0)

我是菜鸟 发表于 2012-10-10 00:54
因为 finally 一定要执行的

只有一种情况不会执行，当执行到System.exit(0)

这个俺知道  求正解

跳到get()方法执行 return 1;然后再继续执行return 2; 所以b就是2啊~~~

给你打个比方，你在A地玩，正准备回家，结果你想起你去B地还有做点事，在B地做完事，由于特殊情况就直接从B地回家了，呵呵……娱乐下

形象啊      果然高手

当finally中有return的时候，try里的return是不执行的。
因为try里遇到return的时候先不执行，这时finally先执行，如果没有return就执行try里的return，如果finally里有return就返回这个值，而不再执行try里的return。

不管前面有多少return,finally中的return将覆盖掉前面的return。
所以最好不要在finally中写return语句。

1. public class SmallT{
   
2.   public static void main(String args[]){
   
3.     SmallT t = new SmallT();
   
4.     int b = t.get();
   
5.     System.out.println(b);
   
6.   }
   
7. 
   
8.   public int get(){
   
9.     try{
   
10.       return 1 ;
    
11.     }
    
12.     finally{
    
13.       try{
    
14.         Thread.sleep(10000);
    
15.         System.out.println("try is running");
    
16.         //return 2 ;
    
17.       }catch(Exception e){}
    
18.     }
    
19.   }
    
20. }
    
21. 
    
22. 运行结果：
    
23. try is running
    
24. 1
    
25. 结果说明问题。
    
26. 
    
27. finally语句优先于try语句执行。try语句的作用是检查其内的语句是否报错。若try、finally里面都有return，则执行
    
28. finally里的，这可能跟虚拟机的机制有关。（按说ftry里的return后执行，不是应该覆盖掉finally里的return值吗？）

复制代码

缘木求鱼 发表于 2012-10-10 10:08

给你讲个故事:
为了证明蜘蛛的听觉在腿上，科学家把蜘蛛放在桌子上，然后大叫一声，蜘蛛吓跑了。然后专家割掉了蜘蛛的全部腿，放在桌子上，大叫一声，蜘蛛没有吓跑，由此可见蜘蛛的听觉在腿上。。

1. public class smallT
   
2. 
   
3. {
   
4. 
   
5. public static void main(String args[])
   
6. 
   
7. {
   
8. 
   
9. smallT t = new smallT();
   
10. 
    
11. int b = t.get();
    
12. 
    
13. System.out.println(b);
    
14. 
    
15. }
    
16. 
    
17. 
    
18. 
    
19. public int get()
    
20. 
    
21. {
    
22. 
    
23. try
    
24. 
    
25. {
    
26. System.out.println("dotry");
    
27. return 1 ;
    
28. 
    
29. }
    
30. 
    
31. finally
    
32. 
    
33. {
    
34. try {
    
35.   Thread.sleep(10000);
    
36. } catch (InterruptedException e) {
    
37.   e.printStackTrace();
    
38. }
    
39.         System.out.println("dofinally");
    
40. return 2 ;
    
41. 
    
42. }
    
43. 
    
44. }
    
45. 
    
46. }
    
47. //输出结果:
    
48. //dotry
    
49. //dofinally
    
50. //2
    
51. //结论是try方法先执行了，finally方法中的return覆盖了之前的return值

复制代码

qhasilver 发表于 2012-10-10 10:27
给你讲个故事:
为了证明蜘蛛的听觉在腿上，科学家把蜘蛛放在桌子上，然后大叫一声，蜘蛛吓跑了。然后专家 ...

讲故事都是有针对性的，看你怎么看待故事阿。我现在有点厌烦人们把花虫鸟兽思考的跟人似的，自私到了极致。
-------------------------------------
正题：但是从我的提供的程序来看的确是try语句后执行了，为什么try语句中的return没有覆盖掉finally语句中的return。反而是finally中的return“覆盖”了try中的return？请从原理上说服我，咋不是小孩拉{:soso_e129:}

smallT t = new smallT();
建立了一个新的smallT()对象
新对象调用get（）方法，先return了1，然后最终执行了finally后面的代码return了2 覆盖了1 所以最终返回了2
并将2赋值给了b
打印b就是2

public class smallT {
        public static void main(String args[]) {
                smallT t = new smallT();
                int b = t.get();
                System.out.println(b);
        }

        public int get() {//在try{}finally{}中，finally中的内容是必须要执行的。你可以当作是finally中的return将try中的return覆盖掉了，使try中return失效。                try {
                        return 1;
                } finally {
                        return 2;
                }
        }
}

缘木求鱼 发表于 2012-10-10 11:32
讲故事都是有针对性的，看你怎么看待故事阿。我现在有点厌烦人们把花虫鸟兽思考的跟人似的，自私到了极致 ...

你故意在finally中添加了休眠时间，想证明就算finally休眠了10秒，也是优先于try执行的对吗？
你看我在try里头写了输出语句，在finally中也写了输出语句。事实上，就算你在try里添加休眠时间，也是try里的语句先输出，finally是最后输出的

缘木求鱼 发表于 2012-10-10 11:32
讲故事都是有针对性的，看你怎么看待故事阿。我现在有点厌烦人们把花虫鸟兽思考的跟人似的，自私到了极致 ...

class Test
{
        private static int b = 5;
        public static void main(String[] args)
        {
                Test t = new Test();
                System.out.println("main:"+b);
                b = t.get();
                System.out.println("t.get():"+b);
        }
        
        public int get()
        {
                int a = 0;
                try
                {
                        a = 10;
                        return 1;
                }
                finally
                {
                        System.out.println("try a:"+a);
                        System.out.println("try b:"+b);
                        return 2;
                }
        }
}

/*

结果：
main:5
try a:10
try b:5
t.get():2
*/

跳到get()方法之后是按顺序执行下去的，return 1;并不是马上把1赋给b

qhasilver 发表于 2012-10-10 13:12
你故意在finally中添加了休眠时间，想证明就算finally休眠了10秒，也是优先于try执行的对吗？
你看我在tr ...

点醒我了，非常感谢。少考虑了那种情况？这样子代码足够说明问题了，的确是顺序执行，finally的return覆盖了try:handshake的
不过还是不大明白，为什么注释掉finally里的return 2后，S.o.p()语句不合和return 1一起打印出来
帮我看看这个问题：
关于TCP多线程上传图片

我是菜鸟 发表于 2012-10-10 13:27
class Test
{
        private static int b = 5;

也非常感谢你，我明白了。我为代码少考虑了一种情况。
帮我看看这个问题：
关于TCP多线程上传图片

这个小题如果在加个catch，执行流程是什么？
public class smallT
{
public static void main(String args[])
{
smallT t = new smallT();
int b = t.get();
System.out.println(b);
}

public int get()
{
try
{
return 1 ;
}catch(Excepiton e){
return  3;
}finally
{
return 2 ;
}
}
}

王虎 发表于 2012-10-10 15:01
这个小题如果在加个catch，执行流程是什么？
public class smallT
{

1. 
   
2. public class smallT
   
3. {
   
4. public static void main(String args[])
   
5. {
   
6. smallT t = new smallT();
   
7. int b = t.get();
   
8. System.out.println(b);
   
9. }
   
10. 
    
11. public int get()
    
12. {
    
13. try
    
14. {
    
15.         System.out.println("dotry");
    
16.         int i = 10/0;//加入一个已知的错误,故意抛出异常
    
17. return 1 ;
    
18. }catch(Exception e){       
    
19.         System.out.println("docatch");
    
20. return  3;
    
21. }finally
    
22. {
    
23.         System.out.println("dofinally");
    
24. return 2 ;
    
25. }
    
26. }
    
27. }
    
28. 
    
29. //输出结果为:
    
30. //dotry
    
31. //docatch
    
32. //dofinally
    
33. //2
    
34. //
    

复制代码

结论是先执行try--再执行catch--再finally

王虎 发表于 2012-10-10 15:01
这个小题如果在加个catch，执行流程是什么？
public class smallT
{

现在明白了  应该还是2:L