final修饰符

final修饰符

final修饰符可以修饰类,方法,成员变量:

修饰类	修饰方法	修饰成员变量
表示类不可以被继承	表示方法不可以被重写	表示是常量,只可以被赋值一次，此后不允许更改

1.final修饰类

表示类不可以被继承,比如String,Math等系统类,不允许子类去继承，默认情况下final类中的方法都是final方法。

2.final修饰方法

表示方法不可以被覆盖，如果一个方法不允许子类去覆盖,就可以使用final修饰，用final修饰方法的好处,其一:可以保护方法内部实现的细节,其二:高效,编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

3.final修饰成员变量

final修饰的成员变量表示是常量只可以被赋值一次，此后编译器不允许对其更改.

4.final修饰函数中的参数

final修饰函数中的参数表示可以被读取但不可以改变参数值.

---

final修饰基本数据类型和引用数据类型的区别

final修饰基本数据类型保证是常量，后续无法对其修改.但对于引用类型的变量而言，它保存的仅仅是一个引用，final只保证这个引用所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变。
eg.

final int[] array={1,3,6,10}
//对数组进行排序，合法
Arrays.sort（array）；
System.out.println(Arrays.toString(iArr));

//对数组元素赋值，合法
arry[2]=-8;

//下面语句对arry重新赋值，非法
arry=null；

因此如果需要设计一个不可变类，必须注意引用类型的属性，如果引用类型是可变的，必须采用必要的措施保护该属性引用对象不会被修改，这样才能创建真正不可变类。

---

为什么匿名内部类中使用的参数必须为final类型?

因为局部变量的生命周期与局部内部类的对象的生命周期的不一致性!

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

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

那么:核心的问题是:怎么才能使得:访问”复制品”与访问真正的原始的局部变量,其语义效果是一样的呢?
当变量是final时,若是基本数据类型,由于其值不变,因而:其复制品与原始的量是一样.语义效果相同.(若:不是final,就无法保证:复制品与原始变量保持一致了,因为:在方法中改的是原始变量,而局部内部类中改的是复制品)

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

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

为了验证上面的结论我们举个例子说明.

public class finalTest {

    private final int anInt=0;
    private final String finalStr="storm";

//    @Before
    public void setUp(){
    }


//    @Test
    public void testFinal(){

        int m=10;

        InnerClass innerClass=new InnerClass() {
            @Override
            void change() {
                System.out.print(m);
            }
        };

        innerClass.change();
    }

     abstract class InnerClass {

        abstract void change();
    }

}

然后通过javac命令进行编译,得到了三个.class字节码文件

finalTest.class

public class finalTest
{
  private final int anInt = 0;
  private final String finalStr = "storm";

  public void setUp() {}

  public void testFinal()
  {
    int i = 10;

    finalTest.1 local1 = new finalTest.1(this, i);

    local1.change();
  }
}

finalTest$1.class

class finalTest$1 extends finalTest.InnerClass
{
  finalTest$1(finalTest paramfinalTest, int paramInt)
  {
    super(paramfinalTest);
  }

  void change()
  {
    System.out.print(this.val$m);
  }
}

finalTest$InnerClass.class

abstract class finalTest$InnerClass
{
  finalTest$InnerClass(finalTest paramfinalTest) {}

  abstract void change();
}

上面的.class文件很好的说明了内部类调用方法内部的局部参数i,是通过内部类的构造函数传递的，这是java中的值传递。为了解决局部参数与内部类对象生命不一致的问题需要定义final类型.