blocks|key|1682253|text|我个人认为这是浪费时间。我认为视觉上的混乱和额外的冗长是不值得的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1682254|我从来没有遇到过这样的情况，我重新分配了一个错误的变量(记住，这并不是说对象是不可变的，它只是意味着你不能再给变量分配另一个引用)。|1682255|当然，这完全是个人喜好;-)|1682256|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

My personal opinion is that it is a waste of time. I believe that the visual clutter and added verbosity is not worth it.

I have never been in a situation where I have reassigned (remember, this does not make objects immutable, all it means is that you can't reassign another reference to a variable) a variable in error.

But, of course, it's all personal preference ;-)

blocks|key|1682332|text|由于(偶尔)Java+"pass+by+reference“行为的令人困惑的本质，我绝对同意结束参数var。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1682333|最终确定本地var似乎有点夸大了IMO。|1682334|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/40480/is-java-pass-by-reference^0|C|H|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Because of the (occasionally) confusing nature of Java's "<a href="https://stackoverflow.com/questions/40480/is-java-pass-by-reference">pass by reference</a>" behavior I definitely agree with finalizing parameter var's. 

Finalizing local var's seems somewhat overkill IMO.

blocks|key|1467046|text|对于局部变量，我倾向于避免这种情况。它会造成视觉混乱，而且通常是不必要的-一个函数应该足够短，或者只关注一个单一的影响，让你很快看到你正在修改一些不应该修改的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1467047|在使用幻数的情况下，我会将它们作为一个常量私有字段，而不是放在代码中。|1467048|我只在必要的情况下使用final+(例如，将值传递给匿名类)。|1467049|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

In the case of local variables, I tend to avoid this. It causes visual clutter, and is generally unnecessary - a function should be short enough or focus on a single impact to let you quickly see that you are modify something that shouldn't be.

In the case of magic numbers, I would put them as a constant private field anyway rather than in the code.

I only use final in situations where it is necessary (e.g., passing values to anonymous classes).

blocks|key|1467090|text|我让Eclipse在匿名类中使用它们时为我做这件事，由于我使用了Google+Collection+API，匿名类的数量正在增加。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1467091|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I let Eclipse do it for me when they are being used in an anonymous class, which is increasing due to my use of Google Collection API.

blocks|key|1682504|text|如果我们认为局部变量不会被重新赋值或不应该被重新赋值，那么我们在这里对它们进行赋值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1682505|参数不是最终的，因为我们有一个Checkstyle-Check，它检查重新分配的参数。当然，没有人会想要重新分配参数变量。|1682506|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

We do it here for the local variables if we think they will not be reassigned or should not be reassigned.

The parameters are not final since we have a Checkstyle-Check which checks for reassigning parameters. Of course nobody would ever want to reassign a parameter variable.

blocks|key|1682567|text|您应该在适当的时候尝试这样做。除了在您“意外”尝试修改某个值时发出警告之外，它还向编译器提供信息，从而更好地优化类文件。这是Robert+Simmons，Jr的"Hardcore+Java“一书中的一个观点。事实上，这本书的第二章都花在了使用final来促进优化和防止逻辑错误上。由于这个原因，诸如PMD和Eclipse的内置SA之类的静态分析工具会标记出这些类型的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1682568|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You should try to do this, whenever it is appropriate. Besides serving to warn you when you "accidentally" try to modify a value, it provides information to the compiler that can lead to better optimization of the class file. This is one of the points in the book, "Hardcore Java" by Robert Simmons, Jr. In fact, the book spends all of its second chapter on the use of final to promote optimizations and prevent logic errors. Static analysis tools such as PMD and the built-in SA of Eclipse flag these sorts of cases for this reason.

blocks|key|1467283|text|是的，去做吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1467284|这是关于可读性的。当您知道变量被赋值一次且仅被赋值一次时，更容易推断出程序的可能状态。|1467285|一个不错的替代方法是，当一个参数被赋值时，或者当一个变量(循环变量除外)被赋值多次时，打开IDE警告。|1467286|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Yes do it.

It's about readability. It's easier to reason about the possible states of the program when you know that variables are assigned once and only once.

A decent alternative is to turn on the IDE warning when a parameter is assigned, or when a variable (other than a loop variable) is assigned more than once.

blocks|key|1467376|text|尽管它造成了一些混乱，但将final放入其中是值得的。Ides，例如eclipse，可以自动放置final，如果您配置它这样做的话。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1467377|entityMap^0|D|5|1C|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Although it creates a little clutter, it is worth putting <code>final</code>. Ides e.g eclipse can automatically put the <code>final</code> if you configure it to do so.

blocks|key|1682722|text|如果你想把局部变量和方法参数传递给匿名类--比如你实例化了一个匿名线程并想要在final+()方法的主体中访问这些参数，那么将这些参数设为run是必不可少的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1682723|除此之外，我不确定通过编译器优化来获得更好的性能会有什么好处。这取决于具体的编译器实现是否要对其进行优化……|1682724|了解使用final的任何性能统计数据将是一件好事……|1682725|entityMap^0|13|5|0|0|4|5|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

Making local variables and method parameters <code>final</code> is essential if you want to pass those parameters into anonymous classes - like you instantiate an anonymous Thread and want to access those params in the body of the run() method.

Apart from that I am not sure of the performance benefits w.r.t better performance through compiler optimization. It is up to the specific compiler implementation whether it wants to optimize it at all...

It will be good to know of any performance stats from using <code>final</code> ...

In Java, you can qualify local variables and method parameters with the final keyword.

<pre><code>public static void foo(final int x) {
 final String qwerty = "bar"; 
}
</code></pre>

Doing so results in not being able to reassign x and qwerty in the body of the method.

This practice nudges your code in the direction of immutability which is generally considered a plus. But, it also tends to clutter up code with "final" showing up everywhere. What is your opinion of the final keyword for local variables and method parameters in Java?

Why would one mark local variables and method parameters as "final" in Java?

编译器

Eclipse

Java

在Java中，您可以使用final关键字来限定局部变量和方法参数。public static void foo(final int x) {  final String qwerty = "bar"; }这样做会导致无法在方法体中重新分配x和qwerty。这种做法将您的代码推向不可变性的方向，这通常被认为是一个加号。但...

问为什么要在Java中将局部变量和方法参数标记为"final“？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么要在Java中将局部变量和方法参数标记为"final“？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么要在Java中将局部变量和方法参数标记为"final“？
EN