java中final关键字注意点

1.匿名内部类的参数引用时final？

因为方法中的局部变量，方法结束后这个变量就要释放掉，final保证这个变量始终指向一个对象。如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。

为什么在匿名内部类中引用外部对象要加final修饰符呢，因为，在匿名内部类中引用的外部对象受到外部线程的作用域的制约有其特定的生命周期，以线程为例，当外部的变量生命周期已经完结之后，内部的线程还在运行，怎么样解决这个外部生命周期已经结束而在内部却需要继续使用呢，这个时候就需要在外部变量中添加final修饰符，其实内部匿名类使用的这个变量就是外部变量的一个“复制品”，即使外部变量生命周期已经结束，内部的“复制品“依然可用。

网络搜索的答案如下：为什么匿名内部类参数必须为final类型
1) 从程序设计语言的理论上:局部内部类(即:定义在方法中的内部类),由于本身就是在方法内部(可出现在形式参数定义处或者方法体处),因而访问方法中的局部变量(形式参数或局部变量)是天经地义的.是很自然的
2) 为什么JAVA中要加上一条限制:只能访问final型的局部变量?
3) JAVA语言的编译程序的设计者当然全实现:局部内部类能访问方法中的所有的局部变量(因为:从理论上这是很自然的要求),但是:编译技术是无法实现的或代价极高.
4) 困难在何处?到底难在哪儿?
局部变量的生命周期与局部内部类的对象的生命周期的不一致性!
5) 设方法f被调用,从而在它的调用栈中生成了变量i,此时产生了一个局部内部类对象inner_object,它访问了该局部变量i .当方法f()运行结束后,局部变量i就已死亡了,不存在了.但:局部内部类对象inner_object还可能 一直存在(只能没有人再引用该对象时,它才会死亡),它不会随着方法f()运行结束死亡.这时:出现了一个”荒唐”结果:局部内部类对象 inner_object要访问一个已不存在的局部变量i!
6) 如何才能实现?当变量是final时,通过将final局部变量”复制”一份,复制品直接作为局部内部中的数据成员.这样:当局部内部类访问局部变量 时,其实真正访问的是这个局部变量的”复制品”(即:这个复制品就代表了那个局部变量).因此:当运行栈中的真正的局部变量死亡时,局部内部类对象仍可以 访问局部变量(其实访问的是”复制品”),给人的感觉:好像是局部变量的”生命期”延长了.
那么:核心的问题是:怎么才能使得:访问”复制品”与访问真正的原始的局部变量,其语义效果是一样的呢?
当变量是final时,若是基本数据类型,由于其值不变,因而:其复制品与原始的量是一样.语义效果相同.(若:不是final,就无法保证:复制品与原始变量保持一致了,因为:在方法中改的是原始变量,而局部内部类中改的是复制品)
当 变量是final时,若是引用类型,由于其引用值不变(即:永远指向同一个对象),因而:其复制品与原始的引用变量一样,永远指向同一个对象(由于是 final,从而保证:只能指向这个对象,再不能指向其它对象),达到:局部内部类中访问的复制品与方法代码中访问的原始对象,永远都是同一个即:语义效 果是一样的.否则:当方法中改原始变量,而局部内部类中改复制品时,就无法保证:复制品与原始变量保持一致了(因此:它们原本就应该是同一个变量.)
一句话:这个规定是一种无可奈何.也说明:程序设计语言的设计是受到实现技术的限制的.这就是一例. 因为:我就看到不少人都持这种观点:设计与想法是最重要的,实现的技术是无关紧要的,只要你作出设计与规定,都能实现.

2.全局变量使用final修饰后，放在堆中，而不是栈中?

非final的成员变量在堆里，final类型的成员变量存放在方法区的常量池中。
java内存模型中将内存分为堆和栈，其中堆为线程间共享的内存数据区域，栈为线程间私有的内存区域。堆又包括方法区以及非方法区部分，栈包括本地方法栈、虚拟机栈等

3.常量池中对象和堆中的对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test{
	public static void main(String[] args){
		Integer i1=new Integer(1);
		   Integer i2=new Integer(1);
		//i1,i2分别位于堆中不同的内存空间
		   System.out.println(i1==i2);//输出false
		   Integer i3=1;
		   Integer i4=1;
		//i3,i4指向常量池中同一个内存空间
		   System.out.println(i3==i4);//输出true
		//很显然，i1,i3位于不同的内存空间
		System.out.println(i1==i3);//输出false
	}
}

8种基本类型的包装类和对象池：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Test{
	
	public static void main(String[] args){
		   //5种整形的包装类Byte,Short,Integer,Long,Character的对象，
		   //在值小于127时可以使用常量池
		   Integer i1=127;
		   Integer i2=127;
		   System.out.println(i1==i2);//输出true
		   //值大于127时，不会从常量池中取对象
		   Integer i3=128;
		   Integer i4=128;
		   System.out.println(i3==i4);//输出false
		   //Boolean类也实现了常量池技术
		   Boolean bool1=true;
		   Boolean bool2=true;
		   System.out.println(bool1==bool2);//输出true
		   //浮点类型的包装类没有实现常量池技术
		   Double d1=1.0;
		   Double d2=1.0;
		   System.out.println(d1==d2);//输出false
		}
}

String也实现了常量池技术：

1
2
3
4
5
6
7
8
9
10
11
12
public class Test{
public static void main(String[] args){
//s1,s2分别位于堆中不同空间
String s1=new String("hello");
String s2=new String("hello");
System.out.println(s1==s2)//输出false
//s3,s4位于池中同一空间
String s3="hello";
String s4="hello";
System.out.println(s3==s4);//输出true
}
}

JDK5.0自动拆装箱：Integer i=Integer.valueOf(5);

这就是Java的装箱.JDK5.0也提供了自动拆箱. Integer i =5; int j = i;