Java中final局部变量的生命周期

Java中final局部变量的生命周期

从C转Java过来，一些基础理论不是太扎实，在使用final局部变量时出现了理解错误，今天验证了一下，记下笔记。

1. public class Main {   
2.        
3.     public void finalTestFunc() {   
4.         final FinalTest t = new FinalTest();   
5.         System.out.println("T:" + t.toString());   
6.     }   
7.   
8.     /**  
9.      * @param args  
10.      */  
11.     public static void main(String[] args) {   
12.         Main m = new Main();   
13.         m.finalTestFunc();   
14.         m.finalTestFunc();   
15.     }   
16.   
17. }  

FinalTest是个空类，啥都没有，toString会转换成其地址打印出来，上面一段程序的打印：

1. T:FinalTest@c17164   
2. T:FinalTest@1fb8ee3  

可以看到在finalTestFunc()函数中虽然t用final修饰了，但是两次调用，每次都创建了新的对象，final只是标记了t在本次调用中不能再次指向别的对象，并不代表这个对象始终存在，整个程序生命周期中只初始化一次。

为什么会有只初始化一次的错误理解呢？
其实刚开始使用Java的时候，理解是正确的，认为每次都初始化。
但是后来使用内部类，内部类如果访问外部类的变量，这个变量就要加final修饰，因为对Java掌握不到位，此时错误的认为final将变量的生命周期改为了整个程序生命周期，而实际上此处加final是保证变量值一致性。

同样在C++中的const也是这个现象，const局部变量的生命周期仍然是局部的，只有加上static才是全局的。

1. #include <iostream>   
2. using namespace std;   
3.   
4. class A {   
5. private:   
6.         int v;   
7.   
8. public:   
9.         A() {   
10.                 v = 0;   
11.         }   
12.   
13.         void out() const {   
14.                 cout << "A=" << this << endl;   
15.         }   
16. };   
17.   
18. class B {   
19. public:   
20.         B() {   
21.         }   
22.   
23.         void constTest() {   
24.                 const A* a = new A();   
25.                 a->out();   
26.         }   
27. };   
28.   
29. int main(int,char**) {   
30.         B* b = new B();   
31.         b->constTest();   
32.         b->constTest();   
33. }  

这段程序输出：

1. A=0x89a8018  
2. A=0x89a8028  

即每次函数调用都创建了新的对象，只有加上在const后加上static，才是只初始化一次。