以上都是正确的。此外，如果您不希望其他人从您的类中创建子类，则将您的类声明为final。然后它就变成了类树层次结构的叶级，没有人可以进一步扩展它。避免庞大的类层次结构是一个很好的实践。

当你让它成为静态final时，它应该在静态初始化块中初始化

    private static final List foo;

    static {
        foo = new ArrayList();
    }

    public Test()
    {
//      foo = new ArrayList();
        foo.add("foo"); // Modification-1
    }

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类。当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缓存，并从主存中进行时间到时间的加载。所以这也是一种性能提升。

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

假设你有两个储蓄罐，红的和白的。你把这些钱箱只分配给两个孩子，他们不允许交换他们的钱箱。所以你有红色或白色的钱箱(最终)，你不能修改盒子，但你可以把钱放在你的盒子上。没人在乎(修改-2)。

final是Java中限制用户的保留关键字，它可以应用于成员变量、方法、类和局部变量。Final变量通常在Java中使用static关键字声明，并被视为常量。例如:

public static final String hello = "Hello";

当我们在变量声明中使用final关键字时，存储在该变量中的值不能在后面更改。

例如:

public class ClassDemo {
  private final int var1 = 3;
  public ClassDemo() {
    ...
  }
}

注意:声明为final的类不能扩展或继承(也就是说，不能有超类的子类)。同样值得注意的是，声明为final的方法不能被子类重写。

使用final关键字的好处将在本文中讨论。