java基础：final关键字的深入使用

java中的final关键字：
final可以修饰变量，被final修饰的变量被赋值之后，不能对它重新赋值
final可以修饰方法，被final修饰的方法不能被重写
final可以修饰类，被final修饰的类不能派生子类


1）final修饰变量
被final修饰的变量必须显式指定初始值，且只能在下面3个位置指定初始值：
定义final实例变量时指定初始值
在非静态代码块中为final实例变量指定初始值
在构造器中为final实例变量指定初始值
使用javap工具编译final修饰的实例变量可以看到，变量的赋值都是放在构造方法中执行的，理论上说final修饰的实例变量的初始化只能
在构造方法中进行。


同样对于final修饰的类变量也必须指定初始值，且只能在2个地方指定初始值：
定义final的类变量时指定初始值
在静态代码块中为final类变量指定初始值
使用javap工具编译final修饰的类变量可以看到，变量的赋值都是放在静态代码块中执行的，理论上说final修饰的类变量的初始化只能
在静态代码块中进行。


2）宏变量
请先看http://blog.youkuaiyun.com/xxqi1229/article/details/6905188中的关于"类变量与实例变量的初始化过程"下面的程序是在原来的程序
上面稍作修改后的。
请看程序：
public class Price {
final static Price INSTANCE = new Price(2.8) ;
final static double initPrice = 20  ;//此变量声明为final类型，此处和源程序不同。
double currentPrice ;
public Price(double discount){
currentPrice = initPrice - discount ;
}
}
测试用例如下：
public class Test {
public static void main(String[] args) {
System.out.println(Price.INSTANCE.currentPrice);
Price p = new Price(2.8) ;
System.out.println(p.currentPrice);
}
}
此时程序的运行结果为：
17.2
17.2
（注：原来程序的运行结果为-2.8 17.2）
为什么加上final关键字后结果就变为17.2呢？对于一个用final修饰的变量而言，如果定义该final变量的时就指定了初始值，而且这个
初始值在编译的时候就可以确定下来，那么这个变量将不再是一个变量，系统会将其当成一个“宏变量”处理，也就是说，在程序中出现
该变量的地方全部把它当成对应的值来处理。
什么叫值在编译时可以确定下来。比如说String s = "aaaaaa";此时在编译的时候就可以确定下来为“aaaaaa”，但是如果定义为
String s = str ;str也是一个字符串类，则此时编译的时候就不能确定s的值是多少。
对于上面的程序而言，由于使用了final关键字修饰initPrice类变量，因此Price类的构造器中执行currentPrice=initPrice-discount；的
时候会将initPrice直接替换为20.因此，执行该代码效果相当于currentPrice=20-discount；
如果把程序中定义initPrice的代码改为如下：
static double d = 20 ;
final static double initPrice = d  ;
则程序运行结果为：
-2.8
17.2
这事因为在编译initPrice的时候不能确定initPrice的值。


3）宏替换
对于一个final变量，不管它是类变量，实例变量还是局部变量，只要定义了该变量时使用了final修饰符修饰，并在定义该final类变量的
时候指定了初始值，而且该初始值可以在编译的时候就确定下来，那么这个final变量本质上已经不再是一个变量，而是一个直接量（宏）。
请看如下程序：
public class Test {
public static void main(String[] args) {
String str1 = "疯狂";
String str2 = "java" ;
final String str3 = "疯狂java";
final String str4 = "疯狂" + "java";
final String str5 = str1 + str2 ;
final String str6 = "疯狂" + String.valueOf("java") ;

System.out.println(str3 == str4);
System.out.println(str3 == str5);
System.out.println(str3 == str6);
}
}
程序运行结果为：
true
false
false
str3 == str4的结果为true，这是因为str4在编译的时候就确定了值。
str3 == str5的结果为false，这事因为str5在编译的时候不能确定值，因为str1和str2不是final类型的，如果把str1和str2定义为final
类型，则str5在编译的时候就可以确定值，此时结果就应该为true。
str3 == str6的结果为false，这是因为表达式中使用了String的方法valueOf，因此在编译的时候无法确定str6的值。


注：对于宏变量只有在定义该变量的时候赋初始值才会有“宏变量”的效果，在非静态代码块、构造方法中为fianl实例变量指定初始值则不会
有这样的效果。
请看下面的程序：
public class FinalInitTest {
final String str1 ;
final String str2 ;
final String str3 = "java" ;
{//非静态代码块中初始化s
str1 = "java" ;
}
public FinalInitTest(){//构造方法中初始化
str2 = "java" ;
}
public void display(){
System.out.println(str1 + str1 == "javajava");
System.out.println(str2 + str2 == "javajava");
System.out.println(str3 + str3 == "javajava");
}

public static void main(String[] args){
FinalInitTest fit = new FinalInitTest() ;
fit.display() ;
}
}
程序的运行结果为：
false
false
true
从程序结果中可以看出，str1和str2没有达到宏替换的母的，这是因为str1在初始化在飞静态代码块中，str2的初始化在构造方法中。
只有在定义final变量的时给定初始值（编译的时候可以确定值）才会达到宏替换的效果。静态final类型的变量也一样。


3）final变量在内部类中的使用
程序需要在匿名内部类中使用局部变量，则局部变量必须声明为final类型。否则会编译错误。为什么必须声明为final类型呢？这是应为
对于普通变量而言，它的作用域是停留在该方法内，当方法执行结束，该局部变量也就随之消失，但内部类则可能产生隐式的“闭包”，
闭包使得局部变量脱离它所在的方法继续存在。
看下面的例子：
public class ClosureTest {
public static void main(String[] args) {
final String str = "java" ;//定义局部变量

new Thread(new Runnable(){
public void run(){
for(int i=0 ;i<100 ; i++){
System.out.println(str + i);
try {
Thread.sleep(100) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start() ;
}
}
程序首先定义了一个局部变量str，当程序main方法执行完成后，str的生命周期就结束了，但是子线程还没有执行结束，而且子线程要
使用main中的局部变量str，这个时候就扩大了str的作用范围。这个时候如果str没有被修饰为final类型，而可以随便改变，则会引起
极大的混乱，因此java编译器要求所有的内部类访问的局部变量必须使用final修饰符修饰。