This question already has an answer here:
I was wondering is there any usability of using final local variables. Variables are not overridden anyway when inheritance comes into picture. For example a simple code as below
public static void main(String args[]) {
final String data = "Hello World!";
System.out.println(data);
}
The example is quite simple one and may not be a relevant code but the question is more generic.I have seen a lot of codes(all incorporated in main function which have final local variables) Is there any usability of declaring local variables as final other than that they cannot be edited in the same function itself?
Firstly, the part about variables being "overridden" - final has two very different meanings. For classes and methods, it's about inheritance; for variables it's about being read-only.
There's one important "feature" of final local variables: they can be used in local (typically anonymous) inner classes. Non-final local variables can't be. That's the primary use of final for local variables, in my experience.
public void foo() {
final String x = "hello";
String y = "there";
Runnable runnable = new Runnable() {
@Override public void run() {
System.out.println(x); // This is valid
System.out.println(y); // This is not
}
};
runnable.run();
}
Note that as a matter of style, some people like to use final even when they're not capturing the variable in a local inner class. I'd certainly be comfortable with final being the default, but a different modifier for "non-final", but I find that adding the modifier explicitly everywhere is too distracting.
final local variables may be accessed from anonymous inner subclasses, whereas non final local variables may not.
Yes, the usability is :- local final variable are accessible by the method inner class. Since local variables live on the stack and exist only for lifetime of the method but Inner class object may live longer so inner class can't access any non final local variable. But once the variable is final then the inner class sure that the value won't change so it keep a private copy of the final local variable for use.
Perfect answer Jon Skeet but there is another (little) benefit of final variables.
The compiler will ensure the final variable is set once and only once.
Let's say you have to initialize a variable and the computation of the value is complex (multiple if-then-else within if-then-else). You might write code that does not initialize the variable in some condition (or initialize it twice). Of course, this is a bug. Making the variable final will allow the compiler to check the final variable is set once and only once. So you will know quickly if you have a bug.
As I said, little benefit but still handy.
yes there is, a small expample where we could normally use it -
Snippet:
final Boolean data = Boolean.TRUE;
button.addListener(SWT.Selection, new Listener() {
public void handleEvent(Event event) {
if (data ) {
....
}
}
});
Its a example of usage with anonymous inner classes. If you want to use your local variable inside inner calss, you have to make final.
Use of final local variables in java
final fields, parameters, and local variables are read-only(means the object's identity, not its state).
You might use final keyword for readability and ensuring it is not modified or in anonymous classes like here:
final String s = "hi";
new Thread(new Runnable() {
@Override
public void run() {
// can use s variable here
}
}).start();
It tells the other programmers that whoever wrote it knew that the value of data shouldn't change once assigned. It's a good habit in my opinion especially declaring the parameter variables as final.
来源：https://stackoverflow.com/questions/18225572/use-of-final-local-variables-in-java