以下是Brian Goetz在this article中所说的内容(对于长报价而言)：

Like many myths about Java performance,the erroneous belief that
declaring classes or methods as final results in better performance is
widely held but rarely examined. The argument goes that declaring a
method or class as final means that the compiler can inline method
calls more aggressively,because it knows that at run time this is
definitely the version of the method that’s going to be called. But
this is simply not true. Just because class X is compiled against
final class Y doesn’t mean that the same version of class Y will be
loaded at run time. So the compiler cannot inline such cross-class
method calls safely,final or not. Only if a method is private can the
compiler inline it freely,and in that case,the final keyword would
be redundant.

On the other hand,the run-time environment and JIT compiler have more
information about what classes are actually loaded,and can make much
better optimization decisions than the compiler can. If the run-time
environment knows that no classes are loaded that extend Y,then it
can safely inline calls to methods of Y,regardless of whether Y is
final (as long as it can invalidate such JIT-compiled code if a
subclass of Y is later loaded). So the reality is that while final
might be a useful hint to a dumb run-time optimizer that doesn’t
perform any global dependency analysis,its use doesn’t actually
enable very many compile-time optimizations,and is not needed by a
smart JIT to perform run-time optimizations.

final is not final any more,at least in Java 5也有一个好帖子.