final关键字可以有两种不同的解释方式，这取决于它的使用对象:

值类型:对于int型，double型等，它将确保值不能改变，

引用类型:对于对象的引用，final确保引用永远不会改变，这意味着它总是引用同一个对象。它不能保证对象中被引用的值保持不变。

因此，final List<Whatever> foo;确保foo总是指向相同的列表，但该列表的内容可能会随着时间的推移而改变。

如果你让foo是静态的，你必须在类构造函数中初始化它(或者你定义它的内联)，就像下面的例子。

类构造函数(不是实例):

private static final List foo;

static
{
   foo = new ArrayList();
}

内联:

private static final List foo = new ArrayList();

这里的问题不是最终修饰符如何工作，而是静态修饰符如何工作。

final修饰符强制在调用构造函数完成之前对引用进行初始化(即必须在构造函数中初始化它)。

当你内联初始化一个属性时，它会在你为构造函数定义的代码运行之前初始化，所以你会得到以下结果:

如果foo是静态的，foo = new ArrayList()将在你为你的类定义的静态{}构造函数执行之前执行 如果foo不是静态的，foo = new ArrayList()将在运行构造函数之前执行

如果不内联初始化属性，final修饰符强制初始化它，并且必须在构造函数中初始化。如果你也有一个静态修饰符，你必须初始化属性的构造函数是类的初始化块:static{}。

您在代码中得到的错误来自于这样一个事实，即静态{}在加载类时运行，在您实例化该类的对象之前。因此，在创建类时，你还没有初始化foo。

可以将静态{}块视为Class类型对象的构造函数。在这里必须初始化静态final类属性(如果不是内联完成的话)。

注:

final修饰符仅对基本类型和引用保证const性。

当你声明一个final对象时，你得到的是该对象的最终引用，但对象本身不是常量。

当你声明一个final属性时，你真正实现的是，一旦你声明了一个特定目的的对象(就像你已经声明的final List)，这个对象将被用于该目的:你不能将List foo更改为另一个List，但你仍然可以通过添加/删除项来改变你的List(你正在使用的List将是相同的，只是它的内容被改变了)。

我想在这里写一个更新的和深入的回答。

Final关键字可以在几个地方使用。

类

final类意味着没有其他类可以扩展这个final类。当Java运行时(JRE)知道一个对象引用的类型是final类(比如F)时，它就知道该引用的值只能是F类型。

Ex:

F myF;
myF = new F();    //ok
myF = someOther;  //someOther cannot be in type of a child class of F.
                  //because F cannot be extended.

因此，当它执行该对象的任何方法时，该方法不需要在运行时使用虚拟表进行解析。即不能应用运行时多态性。所以运行时不会担心这个。这意味着它节省了处理时间，从而提高了性能。

方法

任何类的final方法意味着任何扩展该类的子类都不能重写该final方法。因此，此场景中的运行时行为也与前面提到的类的行为完全相同。

字段，局部变量，方法参数

如果将上述任何类型指定为final，则意味着该值已经最终确定，因此不能更改该值。

Ex:

对于字段，为本地参数

final FinalClass fc = someFC; //need to assign straight away. otherwise compile error.
final FinalClass fc; //compile error, need assignment (initialization inside a constructor Ok, constructor can be called only once)
final FinalClass fc = new FinalClass(); //ok
fc = someOtherFC; //compile error
fc.someMethod(); //no problem
someOtherFC.someMethod(); //no problem

对于方法参数

void someMethod(final String s){
    s = someOtherString; //compile error
}

这仅仅意味着不能更改最终参考值的值。也就是说，只允许一次初始化。在这个场景中，在运行时，由于JRE知道值不能更改，它将所有这些最终确定的值(最终引用的值)加载到L1缓存中。因为它不需要一次又一次地从主存中加载。否则它会加载到L2缓存，并从主存中进行时间到时间的加载。所以这也是一种性能提升。

因此，在上述三种情况下，当我们没有在可以使用的地方指定最后的关键字时，我们不需要担心，编译器优化会为我们做这件事。编译器优化还为我们做了很多其他的事情。：）

java中的final关键字用于限制用户。java final关键字可以在许多上下文中使用。Final可以是:

变量 方法 类

final关键字可以与变量一起应用，没有值的final变量称为空白final变量或未初始化final变量。它只能在构造函数中初始化。空白的final变量也可以是静态的，它只会在静态块中初始化。

Java final变量:

如果你让任何变量作为final，你不能改变final变量的值(它将是常量)。

final变量示例

有一个最终变量的速度限制，我们将改变这个变量的值，但它不能改变，因为最终变量一旦赋值就永远不能改变。

class Bike9{  
    final int speedlimit=90;//final variable  
    void run(){  
        speedlimit=400;  // this will make error
    }  

    public static void main(String args[]){  
    Bike9 obj=new  Bike9();  
    obj.run();  
    }  
}//end of class  

Java最终类:

如果将任何类设置为final类，则不能扩展它。

final类示例

final class Bike{}  

class Honda1 extends Bike{    //cannot inherit from final Bike,this will make error
  void run(){
      System.out.println("running safely with 100kmph");
   }  

  public static void main(String args[]){  
      Honda1 honda= new Honda();  
      honda.run();  
      }  
  }  

Java final方法:

如果您将任何方法设置为final，则不能重写它。

final方法示例 (Honda中的run()不能覆盖Bike中的run())

class Bike{  
  final void run(){System.out.println("running");}  
}  

class Honda extends Bike{  
   void run(){System.out.println("running safely with 100kmph");}  

   public static void main(String args[]){  
   Honda honda= new Honda();  
   honda.run();  
   }  
}  

共享: http://www.javatpoint.com/final-keyword

你总是可以初始化一个final变量。编译器确保你只能做一次。

注意，调用存储在final变量中的对象的方法与final的语义无关。换句话说:final只与引用本身有关，而与被引用对象的内容无关。

Java没有对象不变性的概念;这是通过仔细设计对象来实现的，这是一个远不是微不足道的努力。

阅读所有答案。

在另一个用户案例中，final关键字可以用在方法参数中:

public void showCaseFinalArgumentVariable(final int someFinalInt){

   someFinalInt = 9; // won't compile as the argument is final

}

可用于不应更改的变量。