In swift, it is recommended to declare a variable with let keyword if the variable does not change after initialisation. I see a lot of variables declared as let.
In java, I think the keyword final can serve the same purpose. But from my limited experience, I only see people declaring variables as final in rare circumstance e.g. PI.
Why isn't Java variable declared as final more often? Is there something I'm missing?
see In Java, should I use “final” for parameters and locals even when I don't have to?
Basically, for fields, it is useful and also changes their concurrency properties. see Java concurrency: is final field (initialized in constructor) thread-safe?
However, for local variables and parameters, final's value is less clear. It has some semantic value, but on the other hand, it can also be noise to have
public void foo (final int x, final int y){
try{
final int z = x+y;
}
catch (final Exception z){
final String message = "";
throw new RuntimeException(message);
}
}
compared to
public void foo (int x, int y){
try{
int z = x+y;
}
catch ( Exception z){
String message = "";
throw new RuntimeException(message);
}
}
If you have short methods (which you usually should have), then it is obvious anyway that the variables are not being changed.
Therefore, some developers prefer using final for its semantic value, while others prefer not to use it because of its verbosity.
Java follows the traditional C thinking style where if we are creating something(Primitive types or objects) it is a variable by default and you have to put put "final" in java and "const" in C/C++ to make it a constant. Swift is very new as compare to these languages and its goals are safe programming patterns and simplicity. If you gain further experience in Java you will know that people do use final and best practices more often. The main reason I think(as you have also mentioned) is you have limited exposure to Java.
As described by Marko Topolnik here, when, initializing a variable with final in Java, "the compiler makes sure that you can initialize it only once." If it is a primitive type like int or doubles, it can ensure that the value cannot change. However, for Object (again quoting that answer), "final is only about the reference itself, and not about the contents of the referenced object." It makes no guarantees the values inside the object being referred to staying the same.
For example, I can define a List with final as follows:
final List<String> foo = new ArrayList<String>();
The above List foo cannot be initialized again but its content can be changed, i.e. it does not make foo immutable. Therefore, this make final keyword less useful.
final keyword has its place in declaring a constant value, especially if need only one instance in a class using a static keyword. Following is an example in java.util.Random.Math:
public final class Math {
public static final double PI = 3.14159265358979323846;
Why isn't Java variable declared as final more often? Is there something I'm missing?
What you are missing is "human nature".
Simply, the syntax of Java makes it easier NOT to add the final. And in general, people don't, because it is easier not to.
Note that the "variables are not final by default" design decision comes from Java's ancestry.
Of course, this doesn't address your implied question as to whether Java programmers should use final more often1. But that is a matter of opinion, and StackOverflow discourages opinion-based Q&A's.
1 - .... in contexts where it would be appropriate. Using final where a variable clearly needs to be mutable is counter-productive.
I think this is because there isn't such a "tradition" in Java.
You see, the first book I read about Swift (The Swift Programming Language 2.0 by Apple Inc.) says that every variable you create that is not mutated should be declared as a let constant.
Since The Swift Programming Language 2.0 (the book) is the official guide to Swift, almost everyone follows it. Even if people don't read that book, they will read tutorials written by people who have read that book. As a result, everyone's coding style is like that.
In contrast, the first book I read about Java (Programming with Java for Dummies), doesn't emphasize that we should use final if the value isn't gonna change. And the official documents rarely do that as well. So only a few programmers follow that rule. This resulted in the majority writes code that actually follows this rule.
In addition, You have to write 5 more characters (the word "final" plus a space) to declare a constant in Java, whereas in Swift, you don't write any extra characters (var and let have the same number of characters)! Programmers are lazy, y'know.
At least based on my experience, I am told it is recommended to use final if the variable doesn't change after initiation. For primitive type, JVM will treat it as constant and do some optimisation.
Other occasions like, in Java, all methods are by default virtual unless declared final. It will also gain computation performance.
