final修饰符

final可以修饰变量：被final修饰的变量被赋初值之后，不能对它重新复制。

final可以修饰方法，被final修饰的方法不能被重写。

final可以修饰类，被final修饰的类不能派生子类。

被final修饰的变量必须显式指定初始值，而且只能在如下3个位置指定初始值：

　　1），定义final实例变量的时候指定；

　　2），在非静态初始化块中为final实例变量指定初始值；

　　3），在构造器中为final实例变量指定初始值。

public class FinalInstanceTest {

    final int var1 ="crazy Java".length();
    final int var2;
    final int var3;
    {
        var2 ="abcesdgd".length();
    }
    
    public FinalInstanceTest()
    {
        this.var3 = "xxxxxy".length();
    }
    
    public static void main(String[] args)
    {
        FinalInstanceTest fiv = new FinalInstanceTest();
        System.out.println(fiv.var1);
        System.out.println(fiv.var2);
        System.out.println(fiv.var3);
    }
}

被final修饰的类变量只能在两个地方指定初始值：

　　1），定义final类变量时指定；

　　2），在静态初始化块中为final类变量进行初始化；

final static int var4 = 90;
final static int var5;

static
{
　　var5 = 1000;
}

内部类中的局部变量：

如果程序需要在匿名内部类中使用局部变量，这个局部变量必须使用final修饰。

Java要求被内部类访问的局部变量都使用final修饰的原因：对于普通局部变量而言，它的作用域就是停留在该方法内，当方法执行结束，该局部变量也随之消失；但内部类则可能产生隐式的“闭包Closure”,闭包将使得局部变量脱离它所在的方法继续存在。

import java.util.Arrays;

public class FinalCommandTest {

    public int [] process (IntArrayProductor cmd, int length)
    {
        int [] result = new int[length];
        for(int i=0;i<length;i++)
        {
            result[i] = cmd.product();
        }
        return result;
    }
    public static void main(String[] args)
    {
        FinalCommandTest ct = new FinalCommandTest();
        final int seed =5;
        int [] result = ct.process(new IntArrayProductor() {
            
            @Override
            public int product() {
                // TODO Auto-generated method stub
                return (int) Math.round(Math.random()*seed);
            }
        }, 6);
        System.out.println(Arrays.toString(result));
    }
    
}

interface IntArrayProductor
{
    int product();
}

局部变量脱离它所在方法继续存在的例子：

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 (Exception e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

在main方法中定义的str 对象，main方法的生命周期介绍之后，局部变量str的作用域也会随之结束，但只要新线程里的run方法没有执行完，匿名内部类的实例的生命周期就没有结束，将一直可以访问str局部变量的值。这就是内部类会扩大局部变量作用域的例子。