public class Test1{
         static int v;
        public static void main(String[] args)
        {
               
                Test1 man=new Test1();
                v=man.test();
                System.out.println("最终的v值="+v);
        }
        public  int test()
        {   int a=0;
                try{a=1/0;}
            catch(ArithmeticException e)
            {
                    a=2;
                    return a;
            }        
                finally
                {
                        System.out.println("在finally的v值="+v);

                }
                a=3;       //为什么以下这两句对v的终值没点影响？
      return a;    //
        }

}
/*
结果是这样的：

在finally的v值=0
最终的v值=2

*/

return 是用来结束函数用的,当都到return的时候,其实函数就要结束!..
但是finally的特点就是 没有System.exit(0)的情况,必然会运行.
所以又在函数结束前运行一次finally...但是重点是return语句已经读过了!!!!

结果解释在代码里  希望有帮助！！

1. 
   
2. public class Test1{
   
3.          static int v;
   
4.         public static void main(String[] args)
   
5.         {
   
6.                
   
7.                 Test1 man=new Test1();
   
8.                 v=man.test();
   
9.                 System.out.println("最终的v值="+v);
   
10.         }
    
11.         public  int test()
    
12.         {   int a=0;
    
13.                 try{a=1/0;}
    
14.             catch(ArithmeticException e)
    
15.             {
    
16.                     a=2;
    
17.                     return a;
    
18.             }        
    
19.                 finally
    
20.                 {
    
21.                         System.out.println("在finally的v值="+v);
    
22. 
    
23.                 }
    
24.                 a=3;       //为什么以下这两句对v的终值没点影响？
    
25.       return a;    //
    
26.         }
    
27. 
    
28. }
    
29. /*
    
30. 结果是这样的：
    
31. 
    
32. 在finally的v值=0
    
33. 最终的v值=2
    
34. 因为  try{a=1/0;}这句话会产生异常，执行 catch(ArithmeticException e)代码块，
    
35. 里边有 return a;  而return的时候会查看一下有没有finally代码块，
    
36. 有的话先执行finally，没有的话函数直接结束。不会执行a=3;和 函数外return a;两句。
    
37. 执行finally时，返回V，是返回的全局变量，所以是0
    
38. */
    

复制代码

Up↑Lee↗ 发表于 2014-4-2 13:28
结果解释在代码里  希望有帮助！！

有的话先执行finally，没有的话函数直接结束。     //无论没有没有没有他都会先执行catch后执行finally

1. public class Test1{
   
2.         static int v;
   
3.     public static void main(String[] args)
   
4.     {
   
5.                 Test1 man=new Test1();
   
6.         v=man.test();
   
7.         System.out.println("最终的v值="+v);
   
8.     }
   
9.     public int test()
   
10.     {
    
11.                 int a=0;
    
12.         try{
    
13.                         a=1/0;
    
14.                 }catch(ArithmeticException e){
    
15.                         a=2;
    
16.                         System.out.println("我是第一个执行的！") ;
    
17.             return a;
    
18.         }finally{
    
19.                         System.out.println("在finally的v值="+v);
    
20.                 }
    
21.         a=3;       //为什么以下这两句对v的终值没点影响？
    
22.                 return a;    //因为它前面已经执行过了return了
    
23.     }
    
24. 
    
25. }
    
26. /**
    
27. * 程序执行到a=1/0;时，发现了异常，然后就要去执行catch中的语句，
    
28. * 但是catch中有了return语句，所以程序就结束了，但是finally是
    
29. * 异常的统一出口，所以当程序被return后还会去执行finally，除非
    
30. * 在catch中使用System.exit(0)终止了Java虚拟机。
    
31. * @return
    
32. */

复制代码

王峰峰 发表于 2014-4-2 14:12
有的话先执行finally，没有的话函数直接结束。     //无论没有没有没有他都会先执行catch后执行finally ...

有什么不对么

懂了一点

首先你必须了解一下几点：
       1.一个函数只会返回一次值（可以简单的理解为”return“就是函数的出口，出来之后就结束了）

       2.int类型的静态变量如果不指定初始化值，默认赋值为0

       3.finally｛｝中的代码，除非程序出现RuntimeException异常，否则其中的代码必然会执行

然后分析一下你的代码：
       在”try{a=1/0;}“中出现ArithmeticException 异常，被catch捕获，执行catch中的语句，此时a=2，返回值为2，参照上述第1点，函数应该结束；
       但是JVM发现还有finally关键字，所以它进入finally｛｝中执行“System.out.println("在finally的v值="+v);”参照上面的第2点，所以输出“在finally的v值=0”；至此函数不会继续执行下去，所以“a=3;       //为什么以下这两句对v的终值没点影响？”这段代码不会被执行。
    “v=man.test();”此时v=2，所以输出“最终的v值=2”

1. public class text7 {
   
2.       static int i =2;
   
3.         public static void main(String[] args) {
   
4.                 System.out.println(get());
   
5.                 //finally虽然是最后执行的，但是比return与try中的return优先返回值
   
6.                 System.out.println(i);
   
7.                 }
   
8.                 public static int get(){
   
9.                 try{
   
10.                         System.out.println(i);
    
11.                 return (i=1);
    
12.                 }catch (Exception e) {
    
13.                 }finally{
    
14.                 System.out.println(i = 6);
    
15.                 return 8;  //优先执行finally   return将在函数结束后返回     至于你catch里面什么结果，finally是不管你的
    
16.                 }
    
17.                 //return i = 9;  不会被执行
    
18.                 }
    
19. 
    
20. }
    

复制代码

try{a=1/0;} 是一个异常 在java中 0是不能作为被除数。当try后，会执行 catch 中的语句 a就等于2 同时将a的值返回，赋予v 。 结果在catch时就已经返回，所以下面的语句都不会再继续执行

Up↑Lee↗ 发表于 2014-4-2 13:28
结果解释在代码里  希望有帮助！！

亲，最下面两句也不是在函数外啊，我在书上看到的是，finally结束后，该函数后面还有语句，那后面还得执行的啊

唐僧踏歌 发表于 2014-4-4 07:53
亲，最下面两句也不是在函数外啊，我在书上看到的是，finally结束后，该函数后面还有语句，那后面还得执 ...

大哥   你catch里边有return语句了好吧！执行了这个return。在执行finally  剩下的就不会执行了

return 是用来结束函数用的,当都到return的时候,其实函数就要结束!..
但是finally的特点就是 没有System.exit(0)的情况,必然会运行.