1. package com.itheima;
   
2. 
   
3. public class TestTryCatch {
   
4. 
   
5.         public static void main(String args[]) {
   
6.                 System.out.println(test());
   
7.         }
   
8. 
   
9.         public static int test() {
   
10.                 int k = 0;
    
11.                 try {
    
12.                         k += 2;
    
13.                         return k;
    
14.                 } catch (Exception e) {
    
15.                         k++;
    
16.                         return k;
    
17.                 } finally {
    
18.                         k += 5;
    
19.                 }
    
20.         }
    
21. }

复制代码

大家说这个程序的结果会输出什么？开始我认为输出为7，可是实际输出为2，但是经过调试，在程序返回前是要经过k += 5 这段代码的，并且通过观察点k的值是7，但是真正的输出却是2，这是为什么？

package com.itheima;

public class TestTryCatch {

        public static void main(String args[]) {
                System.out.println(test());
        }

        public static int test() {
                int k = 0;
                try {
                        k += 2;
                        return k;
                } catch (Exception e) {
                        k++;
                        return k;//在这里已经返回了值
                } finally {//因为这个无论怎么样都会执行
                        k += 5;//这是返回之后才加的，所以是2时候已经返回，换回之后才加到7
                }
        }
}

try..catch..finally,语句是这样的
try
{
//这里放可能会出现异常的代码；

}
catch(Exception e)
{
//这里放处理异常的代码；只有在try时发生了异常，这里的代码才会被运行；
}
finally
{
//这里存放的是一定会执行的代码，不管try发生了异常没有，他都会运行，所以一般这里放关闭资源等代码；
}


根据，你的代码分析来看：
首先在try中，k的值已经变成2，返回了，这时k的值是2；
但是你下面还有一个finally，这里的代码一定会被执行，那么，k += 5 的值就是 2+5就等于7；

finally里的的代码无法修改return的值，其他值还是可以，具体为什么，没有深入研究过，你可以在finally里修改并打印一个没有返回的值就能看到结果是可以被修改的，但是return的值不行

try {
                 k += 2;
                  return k;// k的值在这里已经返回了  而且System.out.println(test());这句也正是打印返回的值
       }
catch (Exception e)
              {
                 k++;
                      return k;
               }
   finally {
                     k += 5;//这句话实在返回以后才加上的  而k是方法中的局部变量 方法执行完毕则死亡
            }

如果这么写，则打印的是7
try {
                 k += 2;
       }
catch (Exception e)
              {
                 k++;
                      return k;
               }
   finally {
                     k += 5;
                    return k;
            }

1. public static void main(String[] args) {
   
2.                
   
3.                 int i = test();
   
4.                 System.out.println(i);
   
5.         }
   
6.        
   
7.         public static int test() {
   
8.                
   
9.                 int i = 123;
   
10.                
    
11.                 int x = 123;
    
12.                
    
13.                 try {
    
14.                         System.out.println("--------try---------");
    
15.                
    
16.                         return i;
    
17.                        
    
18.                 } finally {
    
19.                        
    
20.                         i += 222;
    
21.                        
    
22.                         x += 222;
    
23.                        
    
24.                         System.out.println("---------finally-------x="+x+"-------i="+i);
    
25.                 }
    
26.                
    
27.         }

复制代码

--------try---------
---------finally-------x=345-------i=345
123

其实都被修改了，先执行finally里的代码，但return的那个值，不会变了，finally执行完，才会真正返回这个值

path环境变量和classpath环境变量

如果我们要使用计算机中的某条命令，首先必须要找到这条命令，我们才可以使用它，否则在命令行中会报找不到此命令的错误，那么在计算机中是怎么找一条命令并执行它呢？

我们可以配置path环境变量，这样就可以在任何目录下执行在path变量中配置路径下的命令。配置path环境变量就是给要执行的命令指定路径。

classpath环境变量，java中，在jdk1.5后已经不需要配置classpath环境变量了，classpath环境变量是让其加载器自动加载classpath环境变量下的class文件。使在任何目录下都可以执行同一目录下的class文件。

但是，classpath环境变量尽量少用，因为，一旦配置了classpath，在我们执行class文件的时候，本来是要到当前目录下执行我们需要执行的文件，但是不小心，当前目录下的class文件被删/或不存在，那么它就会自动的执行classpath环境变量下的class文件，这就造成我们不想看到的结果。在java的JDK1.5后就不需要我们配置classpath环境变量了。这给我们减少了很多麻烦。

配置path环境变量的技巧：
我们配置path环境变量的时候，路径会改变，会造成路径改错。我们可以使用用户变量如：JAVA_HOME配置jdk路径，再把JAVA_HOME作内容配置在path环境变量中。

我们到别人的计算机上运行或编写一个java程序，别人机器上又没有装有jdk。我们也不需要去装一个jdk，更不需要配置path环境变量，这里我们可以使用set命令临时的配置一个环境变量。
如set path=jdk路径