听起来，反对使用最后一个关键字的最大论点之一是“这是不必要的”，而且它“浪费空间”。

如果我们承认“final”的许多好处，同时承认它需要更多的输入和空间，我认为Java应该默认将变量设置为“final”，并且如果编码器想要的话，就要求将变量标记为“mutable”。

为:

Final fields - Marking fields as final forces them to be set by end of construction, making that field reference immutable. This allows safe publication of fields and can avoid the need for synchronization on later reads. (Note that for an object reference, only the field reference is immutable - things that object reference refers to can still change and that affects the immutability.) Final static fields - Although I use enums now for many of the cases where I used to use static final fields.

考虑但审慎地使用:

最终类——框架/API设计是我唯一考虑的情况。 Final方法——基本上与Final类相同。如果你疯狂地使用模板方法模式，并把东西标记为final，你可能太依赖继承而不是委托。

忽略，除非感觉肛门:

Method parameters and local variables - I RARELY do this largely because I'm lazy and I find it clutters the code. I will fully admit that marking parameters and local variables that I'm not going to modify is "righter". I wish it was the default. But it isn't and I find the code more difficult to understand with finals all over. If I'm in someone else's code, I'm not going to pull them out but if I'm writing new code I won't put them in. One exception is the case where you have to mark something final so you can access it from within an anonymous inner class.

我从来没有遇到过在变量上有最后一个关键字就能阻止我犯错误的情况，所以目前我认为这是一种巨大的浪费时间。

除非有真正的理由这样做(比如你想要明确指出变量是final的)，否则我宁愿不这样做，因为我发现这样做会使代码的可读性降低。

但是，如果您没有发现它会使代码更难阅读或更长时间地编写，那么无论如何都可以使用它。

编辑:作为一个澄清(并试图赢回反对票)，我不是说不要将常量标记为最终值，我是说不要做这样的事情:

public String doSomething() {
  final String first = someReallyComplicatedExpressionToGetTheString();
  final String second = anotherReallyComplicatedExpressionToGetAnother();

  return first+second;
}

在我看来，这只是让代码更难阅读。

同样值得记住的是，所有final的作用都是防止你重新分配变量，它并没有使它成为不可变或类似的东西。

I have to read a lot of code for my job. Missing final on instance variables is one of the top things to annoy me and makes understanding the code unnecessarily difficult. For my money, final on local variables causes more clutter than clarity. The language should have been designed to make that the default, but we have to live with the mistake. Sometimes it is useful particularly with loops and definite assignment with an if-else tree, but mostly it tends to indicate your method is too complicated.

选择为每个方法中的每个参数输入final会让编码员和代码读者感到非常恼火。

一旦愤怒超出合理范围，切换到Scala，默认情况下参数是最终的。

或者，您总是可以使用代码样式工具，它将自动为您完成这些工作。所有ide都实现了它们或作为插件。

Even for local variables, knowing that it is declared final means that I don't need to worry about the reference being changed later on. This means that when debugging and I see that variable later on, I am confident that it is referring to the same object. That is one less thing I need to worry about when looking for a bug. A bonus is that if 99% of variables are declared final, then the few variables which really are variable stand out better. Also, the final lets the compiler find some more possible stupid mistakes that might otherwise go unnoticed.