Access to static fields in enum constructor is forbidden by the compiler. The source code below works, it uses a static field:
public enum TrickyEnum { TrickyEnum1, TrickyEnum2; static int count; TrickyEnum() { incrementCount(); } private static void incrementCount() { count++; } public static void main(String... args) { System.out.println("Count: " + count); } }
Output:
Count: 2.
But the code below does not work despite there being very little difference:
public enum TrickyEnum { TrickyEnum1, TrickyEnum2; static int count; TrickyEnum() { count++; //compiler error } public static void main(String... args) { System.out.println("Count: " + count); } }
From my search, people usually claim that the problem is due to the order in which static fields are initialized. But first example works, so why do Java developers forbid the second example? It should also work.
The constructor takes a string value as a parameter and assigns value to the variable pizzaSize . Since the constructor is private , we cannot access it from outside the class. However, we can use enum constants to call the constructor.
If you declare a static variable in a class, if you haven't initialized it, just like with instance variables compiler initializes these with default values in the default constructor. Yes, you can also initialize these values using the constructor.
But in case of Enums we cannot alter order of static fields. The first thing in enum must be the constants which are actually static final instances of enum type.
By default, enums don't require constructor definitions and their default values are always the string used in the declaration.
The compiler allows a call to a static function, because it is not smart enough to prohibit it: the legitimacy of the call cannot be deduced without looking into the body of the incrementCount
method.
The reason this is prohibited becomes clear when you run the following code:
enum TrickyEnum { TrickyEnum1, TrickyEnum2; static int count = 123; // Added an initial value TrickyEnum() { incrementCount(); } private static void incrementCount() { count++; System.out.println("Count: " + count); } public static void showCount() { System.out.println("Count: " + count); } } public static void main (String[] args) throws java.lang.Exception { TrickyEnum te = TrickyEnum.TrickyEnum1; TrickyEnum.showCount(); }
This prints
1 2 123
which is extremely confusing to a programmer reading your code: essentially, incrementCount
does its modifications to the static field before it has been initialized.
Here is a demo of this code on ideone.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With