为什么匿名内部类参数必须为final类型

局部变量的生命周期与局部内部类的对象的生命周期的不一致。

内部类里面使用外部类的局部变量时，其实就是内部类的对象在使用它，内部类对象生命周期中都可能调用它，而内部类试图访问外部方法中的局部变量时，外部方法的局部变量很可能已经不存在了，那么就得延续其生命，拷贝到内部类中，而拷贝会带来不一致性，从而需要使用final声明保证一致性。

局部内部类（即：定义在方法中的内部类），由于本身就是在方法内部（可出现在形式参数定义处或者方法体处），因而访问方法中的局部变量（形式参数或局部变量）是天经地义的。是很自然的

设方法f被调用，从而在它的调用栈中生成了变量i,此时产生了一个局部内部类对象inner_object,它访问了该局部变量i .当方法f（）运行结束后，局部变量i就已死亡了，不存在了。但：局部内部类对象inner_object还可能 一直存在（只能没有人再引用该对象时，它才会死亡），它不会随着方法f（）运行结束死亡。这时：出现了一个“荒唐”结果：局部内部类对象inner_object要访问一个已不存在的局部变量i!

6） 如何才能实现？当变量是final时，通过将final局部变量“复制”一份，复制品直接作为局部内部中的数据成员。这样：当局部内部类访问局部变量时，其实真正访问的是这个局部变量的“复制品”（即：这个复制品就代表了那个局部变量）。因此：当运行栈中的真正的局部变量死亡时，局部内部类对象仍可以访问局部变量（其实访问的是“复制品”），给人的感觉：好像是局部变量的“生命期”延长了。

package jin.feng1;

abstract class Base{
	public Base(int i){
		i=i+1;
	System.out.print("Base constructor,i="+i);
	}
	public abstract void f();
}
public class AnonymousConstructor
{
	public static Base getBase(final int i){
		return new Base(i){    

 //这里是正常访问基类构造函数，构造函数仅仅访问一次，而且方法结束后构造函数不可能再调用，因此不需要是final类型
			private int j=i;//复制一份
			{System.out.print("inside :"+j);}			
			public void f()
			{
				System.out.print("f()");					
			}};
		
	}
	
	public static void main(String[] args)
	{
	Base ba=getBase(21);
	ba.f();
	}

}

output//

Base constructor,i=22inside :21f()

那么：核心的问题是：怎么才能使得：访问“复制品”与访问真正的原始的局部变量，其语义效果是一样的呢？

当变量是final时，若是基本数据类型，由于其值不变，因而：其复制品与原始的量是一样。语义效果相同。（若：不是final,就无法保证：复制品与原始变量保持一致了，因为：在方法中改的是原始变量，而局部内部类中改的是复制品）

当变量是final时，若是引用类型，由于其引用值不变（即：永远指向同一个对象），因而：其复制品与原始的引用变量一样，永远指向同一个对象（由于是final,从而保证：只能指向这个对象，再不能指向其它对象），达到：局部内部类中访问的复制品与方法代码中访问的原始对象，永远都是同一个即：语义效果是一样的。否则：当方法中改原始变量，而局部内部类中改复制品时，就无法保证：复制品与原始变量保持一致了（因此：它们原本就应该是同一个变量。）

一句话：这个规定是一种无可奈何。也说明：程序设计语言的设计是受到实现技术的限制的。这就是一例。 因为：我就看到不少人都持这种观点：设计与想法是最重要的，实现的技术是无关紧要的，只要你作出设计与规定，都能实现。

现在我们来看，如果我要实现一个在一个方法中匿名调用ABSClass的例子：

public static void test（final String s）{

//或final String s = “axman”;

ABSClass c = new ABSClass（）{

public void m（）{

int x = s.hashCode（）；

System.out.println（x）；

}

};

//其它代码。

}

从代码上看，在一个方法内部定义的内部类的方法访问外部方法内局部变量或方法参数，是非常自然的事，但内部类编译的时候如何获取这个变量，因为内部类除了它的生命周期是在方法内部，其它的方面它就是一个普通类。那么它外面的那个局部变量或方法参数怎么被内部类访问？编译器在实现时实际上是这样的：

public static void test（final String s）{

//或final String s = “axman”;

class OuterClass$1 extends ABSClass{

private final String s;

public OuterClass$1（String s）{

this.s = s;

}

public void m（）{

int x = s.hashCode（）；

System.out.println（x）；

}

};

ABSClass c = new OuterClass$1（s）；

//其它代码。



}

即外部类的变量被作为构造方法的参数传给了内部类的私有成员。

假如没有final,那么：

public static void test（final String s）{

//或final String s = “axman”;

class OuterClass$1 extends ABSClass{

private final String s;

public OuterClass$1（String s）{

this.s = s;

}

public void m（）{

int x = s.hashCode（）；

System.out.println（x）；

}

};

ABSClass c = new OuterClass$1（s）；

//其它代码。



}

就会编译成：

public static void test（String s）{

//或String s = “axman”;

class OuterClass$1 extends ABSClass{

private String s;

public OuterClass$1（String s）{

this.s = s;

}

public void m（）{

s = “other”;

}

};

ABSClass c = new OuterClass$1 （s）；

}

内部类的s重新指向“other”并不影响test的参数或外部定义的那个s.同理如果外部的s重新赋值内部类的s也不会跟着改变。

而你看到的

public static void test（String s）{

//或String s = “axman”;

ABSClass c = new ABSClass（）{

public void m（）{

s = “other”;

}

};

System.out.println（s）；

}

在语法上是一个s,在内部类中被改变了，但结果打印的出来的你认为是同一的s却还是原来的“axman”,

你能接收这样的结果吗？

所以final从语法上约束了实际上两个不同变量的一致性（表现为同一变量）。

 

 

参考：http://www.educity.cn/java/503969.html

http://www.cnblogs.com/albert1017/p/3915356.html