为什么匿名内部类参数必须为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,从而保证:只能指向这个对象,再不能指向其它对象),达到:局部内部类中访问的复制品与方法代码中访问的原始对象,永远都是同一个即:语义效 果是一样的.否则:当方法中改原始变量,而局部内部类中改复制品时,就无法保证:复制品与原始变量保持一致了(因此:它们原本就应该是同一个变量.) 

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

 

现在我们来看,如果我要实现一个在一个方法中匿名调用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(String s){ 
     //或String s = "axman"; 
  ABSClass c = new ABSClass(){ 
   public void m(){ 
     s = "other"; 
   } 
  }; 
  System.out.println(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从语法上约束了实际上两个不同变量的一致性(表现为同一变量).

===================================================================================================================

final从字面上理解含义为“最后的，最终的”。在Java中也同样表示出此种含义。

final可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

1. final修饰类:

final修饰类即表示此类已经是“最后的、最终的”含义。因此，用final修饰的类不能被继承，即不能拥有自己的子类。

如果视图对一个已经用final修饰的类进行继承，在编译期间或发生错误。

 

2. final修饰方法：

final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。

此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，

将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是

在子类中重新定义了新的方法。

 1 public class B extends A { 2  3     public static void main(String[] args) { 4  5     } 6  7     public void getName() { 8          9     }10 }11 12 class A {13 14     /**15      * 因为private修饰，子类中不能继承到此方法，因此，子类中的getName方法是重新定义的、16      * 属于子类本身的方法，编译正常17      */18     private final void getName() {19         20     }21 22     /* 因为pblic修饰，子类可以继承到此方法，导致重写了父类的final方法，编译出错23     public final void getName() {24     25     }26     */27 }

 

3. final 修饰变量：

final修饰的变量表示此变量是“最后的、最终的”含义。一旦定义了final变量并在首次为其显示初始化后，final修饰的变量值不可被改变。

这里需要注意以下几个问题：

1. final修饰的变量，无论是类属性、对象属性、形参还是局部变量，这些变量都是需要进行显示初始化（即为其显示指定初始值）。

对于final修饰的形参，由于是实参传递过来的，很好理解。

对于final修饰的局部变量，与未用final修饰的变量一样，都是需要显示初始化。即局部变量都是需要显示初始化的。

对于一般的类属性和对象属性，由类和对象的初始化过程中可以看出，首先都进行了默认初始化。然后对有显示赋值的变量才再进行显示初始化。

但对final修饰的类属性和对象属性而言，如果不显示初始化，其默认将是进行默认初始化后的值，这与final本身出发点矛盾，因此，Java语法规定：

final修饰的类属性和变量属性必须要进行显示初始化赋值。

另外，无论对于基本数据类型还是引用数据类型，final修饰的变量都是首次显示初始化后值都不能修改。对于基本数据类型，很好理解。对于引用

数据类型，引用变量指向的是实际的对象，但其存储的是所指向对象的地址，因此，其值不能修改并不意味着其所指向的对象不能修改。

 

4. final修饰变量后导致的“宏替换”/"宏变量"问题

Java 中宏变量/宏替换指的是在java代码中在编译期某些变量能够直接被其本身的值所替换，编译到.class文件中。因此，编译后的.class文件中已经不存在此变了。

在String类型的变量中，有时候经常遇到如下情况：

 1 public class Test { 2  3     public static void main(String[] args) { 4  5         String country = "China"; 6         String name = "qqyumidi"; 7  8         String userInfo = country + name;  //编译后此处依然是country和name变量 9         String user = "China" + "qqyumidi";  //编译后此处直接变成Chinaqqyumidi10 11     }12 }

在上述代码中的第9行，编译后的变量结果直接为Chinaqqyumidi。而第8行代码中，由于country和name都是普通的变量，编译器无法在编译时直接确定userInfo的值，因此

此处编译后结果不直接是Chinaqqyumidi。

但是，如果希望第8行中的代码在编译期直接就能表示为Chinaqqyumidi，就需要用到final修饰符对country和name变量进行修饰。

原因：final修饰符修饰的变量在由于其本身的特性，在编译期就能直接确定其值，且此值不可变。在编译过程中，可以直接将其变量直接转换成其值本身去表示。

 1 public class Test { 2  3     public static void main(String[] args) { 4  5         final String country = "China"; 6         final String name = "qqyumidi"; 7  8         String userInfo = country + name;  //编译后此处直接是Chianqqyumidi 9 10     }11 }