Why the Java const keyword is unimplemented
The original architects of the Java language reserved the const keyword, yet the term has never been implemented and most likely never will be. Many developers wonder why.
What does const in Java even mean?
Anyone who sees the const keyword in Java would logically assume its original intention was to define a constant value. That assumption isn’t too far off the mark.
Both C and C++ use the const keyword, but those languages aren’t purely object-oriented like Java is, and that belies the crux of the problem.
After all, what exactly would it mean for something to be a const in Java?
- An instance variable doesn’t change?
- A class variable doesn’t change?
- An object’s methods can’t be overridden?
- An object reference doesn’t change?
- An object is immutable?
In addition to the above questions, here’s another big one: “Is an object only constant under a specific set of circumstances?”
For example, some languages allow const to be part of a method signature, which indicates that an object and its properties can’t change for the short period of time in which they are used inside a method. This is sometimes referred to as const-correctness.
Language architects may find themselves down a deep rabbit hole as they try to nail down the meaning of the const keyword.
Why is Java’s const keyword unimplemented?
The const keyword is not implemented in Java because Java’s final keyword does a better job of expressing what it means to be a constant in an object-oriented system.
In Java, final is used to perform the following tasks:
- Mark a primitive value as being constant.
- Indicate a method cannot be overridden.
- Specify that an object reference cannot change.
- Ensure a variable is unchanged within a method.
When Java’s static and final keywords are combined, a class-level variable can be made constant, which essentially turns it into a global variable.
This doesn’t quite cover all the different scenarios in which the const keyword is used in other languages, but it comes close. Furthermore, the choice to combine static and final provides greater flexibility in how constant properties behave, as opposed to the use of just one keyword that tries to address both instance and class-level semantics.
When developers consider the power and flexibility the language provides by allowing them to daisy-chain the static and final keywords, one might deduce that the reason why the const keyword in Java is unimplemented is because it’s actually not needed.
The static and final keyword combination effectively provides a more expressive way to declare unchanging variables, compared with an implementation of the const keyword in Java.
In terms of fully immutable objects, the historic workaround has been to declare instance variables private and restrict access through public setters and getters. More recently, Java has introduced the concept of Java Records. This adds immutable, reference-free objects to the language, and again provides a Java language syntax that implements a concept some might associate with const.
Why does Java even have a const keyword?
Discussions about using the const keyword in Java to implement const-correctness started back in 1999, but the enhancement proposal was rejected as feature creep. Language architects asserted that the addition of a const implementation in Java after a full increment — long-term support release of the JDK was already out the door — would cause code bloat and potentially issues with backwards compatibility.
The idea of implementing the const keyword in Java hasn’t been revisited since.
The const keyword in Java cannot be used without causing a compile time error.
Will const in Java ever be implemented?
Why make const a reserved word if there was no intention to implement it?
One possible reason is to just avoid confusion.
If const wasn’t a reserved word, developers would be allowed to use the phrase to name variables. Just imagine the confusion for C++ and JavaScript developers who learned to program with languages where const has an implementation.
Simply making the const keyword in Java a reserved word helps avoid any confusion.