Re: Global enums and constants
Roedy Green wrote:
Lew wrote, quoted or indirectly quoted someone who said :
Being 'static' is not part of the definition of a Java constant variable.
"We call a variable, of primitive type or type String, that is final and
initialized with a compile-time constant expression (=A715.28) a constant=
variable."
Constant in Java land just means not-changing once defined. In
One must be careful not to entangle the common use of the term "constant" in
this sense from the formal definition in Java.
ordinary language, it means something like pi, that has a universal
fixed value.
In java every instance of a class might define a constant a different
way.
True. However, whether that declaration indeed defines a constant is strictly
in accordance with the language rules.
Java also makes a distinction between constants it can compute at
compile time then treat like literals and once it must defer until run
time.
Exactly so, and this is where rigid adherence to the formal language is useful.
Roedy is correct that most Java programmers define "constant" informally as
"immutable", which is valid but wider than the formal definition. This plays
into whether you use all-upper-case variable names or not.
While Java defines "constant" as inclusive of instance variables, most
programmers don't think of it that way. House styles vary, but a common Java
convention "free parking" variant is to declare all static immutable members
with all-upper-case identifiers, whether constant or not, and no immutable
instance members in all upper-case, even though they be constants.
public class NamingConventionMutability
{
public static final String THIS_IS_A_CONSTANT = "constant";
public static final String NOT_A_CONSTANT = new String("constant");
public static final String ALSO_A_CONSTANT = THIS_IS_A_CONSTANT + "!";
public final String thisIsAConstant = "constant";
public final String notAConstant = new String("constant");
public final String alsoAConstant = thisIsAConstant + "!";
}
The first kind get you in trouble, though they are more efficiently
handled.. If you change them, you need to do a clean compile to get
the new value propagated to all classes that use it.
Constants get you into trouble if you don't understand what constitute formal
constants in Java. If you do, the subtleties are unconfusing. A constant is
compiled in the way a literal is compiled in: as a literal. You no more expect
a class to detect a change in a constant than you expect to detect a change in
42. Non-constant immutables are a different matter.
They get you out of more trouble than they get you into. More generally,
immutable types get you out of trouble, in particular but not only with
concurrent programming.
Lengthy SSCCE follows:
<sscce>
<source name="exercise/Immutable.java">
package exercise;
/** Immutable type with constant. */
public class Immutable
{
/** Constant. */
public static final String CONSTANT = "constant";
/** Immutable, not constant. */
public static final String NOT_CONSTANT = new String("not constant");
@Override public String toString()
{
String id = super.toString();
return CONSTANT + id.substring(id.indexOf('@'));
}
}
</source>
<source name="exercise/Foo.java">
package exercise;
/** Illustrate difference between immutable and constant. */
public class Foo
{
public static void main(String[] args)
{
final Immutable immutable = new Immutable();
System.out.println("immutable = \"" + immutable + '"');
System.out.println("Immutable.CONSTANT = \"" + Immutable.CONSTANT + '"');
System.out.println("immutable.CONSTANT = \"" + immutable.CONSTANT + '"');
System.out.println("Immutable.NOT_CONSTANT = \""
+ Immutable.NOT_CONSTANT + '"');
System.out.println("immutable.NOT_CONSTANT = \"" +
immutable.NOT_CONSTANT + '"');
}
}
</source>
<output>
$ javac -d ../../build/classes/ exercise/Immutable.java exercise/Foo.java
$ java -cp ../../build/classes exercise.Foo
immutable = "constant@512fb063"
Immutable.CONSTANT = "constant"
immutable.CONSTANT = "constant"
Immutable.NOT_CONSTANT = "not constant"
immutable.NOT_CONSTANT = "not constant"
lewie@cydnyy~/projects/webxercises/src/java</output>
</sscce>
Now change 'Immutable' and recompile only it:
<sscce>
<source name="exercise/Immutable.java">
package exercise;
/** Immutable type with constant. */
public class Immutable
{
/** Constant. */
public static final String CONSTANT = "different constant";
/** Immutable, not constant. */
public static final String NOT_CONSTANT =
new String("different not constant");
@Override public String toString()
{
String id = super.toString();
return CONSTANT + id.substring(id.indexOf('@'));
}
}
</source>
<output>
$ javac -d ../../build/classes/ exercise/Immutable.java
$ ls -l ../../build/classes/exercise/
total 8
.... 1041 2012-02-15 16:20 Foo.class
.... 767 2012-02-15 16:22 Immutable.class
# as you can see, Foo.class is older than Immutable.class.
$ java -cp ../../build/classes exercise.Foo
immutable = "different constant@11e55d39"
Immutable.CONSTANT = "constant"
immutable.CONSTANT = "constant"
Immutable.NOT_CONSTANT = "different not constant"
immutable.NOT_CONSTANT = "different not constant"
</output>
</source>
Amazingly, the value for 'CONSTANT' did not change in 'Foo', though it did in
'Immutable'. Equally amazingly, the value for 'NOT_CONSTANT' did change. Also
equally amazing is that the 'Immutable#toString()' expression that relies on
'Immutable.CONSTANT' did change in 'Foo'.
--
Lew