Why do I get an NPE when a nested Enum references a parent static member in its constructor?

Question

Conditions to recreate (as far as I can tell):

1. nested enum references a parent static member
2. nested class
3. static member of parent class takes enum as an constructor argument to nested class
4. enum is referenced by an external class before anything else in the parent class

Run this code online: https://repl.it/repls/PlushWorthlessNetworking

import java.util.ArrayList;

class Recreate {

  private static ArrayList FEATURES = new ArrayList();

  public enum Car {
    TESLA(FEATURES);
    Car(ArrayList l) { }
  }

  public static class Garage {
    final Car car;

    Garage(Car car) {
      this.car = car;
    }
  }

  public static Garage ONE_CAR_GARAGE = new Garage(Car.TESLA);
}

class Main {
  public static void main(String[] args) {
    // inclusion of this line causes the next line to NPE
    System.out.println(Recreate.Car.TESLA);

    System.out.println(Recreate.ONE_CAR_GARAGE.car.toString());
  }
}

Answer 1

Here is what is happening:

1. The main method starts executing
2. You refer to Recreate.Car.TESLA
3. The classloader starts to load and initialize enum Car. As noted below, class Recreate is NOT yet loaded or initialized.
4. The initializer for TESLA refers to FEATURES
5. This causes class Recreate to be loaded and initialized
6. As part of static initialization of Recreate, Class Garage is loaded, intialized, and the instance ONE_CAR_GARAGE is created.

The problem here is that at this point, the construction of enum Car is not complete, and Car.TESLA has the value null.

Even though classes may be nested, it is not the case that nested classes are loaded and initialized as part of the outer class initialization. They may look nested in the source but each and every class is independent. Static nested classes are equivalent to top-level classes. Non-static classes are also the same but have the ability to refer to members in the containing class via a hidden reference.

You can see for yourself if you run this in a debugger, put breakpoints in several places, and examine the stack at each breakpoint.

I tested/debugged this in Eclipse with the following code, with breakpoints set where indicated. It's slightly different from your code but shouldn't behave differently:

public class Foo5
{
    static class Recreate {

        private static ArrayList FEATURES = new ArrayList();

        public  enum Car {
          TESLA(FEATURES);
          Car(ArrayList l) { 
              System.out.println("car"); // *** Breakpoint ***
          }
        }
        public static Garage ONE_CAR_GARAGE = new Garage(Car.TESLA);

        public static class Garage {
            final Car car;

            Garage(Car car) {
              this.car = car;  // *** Breakpoint ***
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Recreate.Car car = Recreate.Car.TESLA;
        System.out.println(Recreate.Car.TESLA);
        System.out.println(Recreate.ONE_CAR_GARAGE.car.toString());
    }   
}

The first breakpoint you will hit will be the one in the Garage(Car car) constructor. Examining the stack at that point you will see

Foo5$Recreate$Garage.<init>(Foo5$Recreate$Car) line: 23 
Foo5$Recreate.<clinit>() line: 17   
Foo5$Recreate$Car.<clinit>() line: 12   
Foo5.main(String[]) line: 29    

So when the Garage constructor is called, it has not yet returned from creating Car. This is dictated by the convoluted dependencies you have created between classes, so the solution is to untangle the dependencies. How you do that will depend on your ultimate goals.

Answer 2

You have a hidden circular dependency that's confusing the JVM. Let's take a look at your code.

class Recreate {

  private static ArrayList FEATURES = new ArrayList();

  public enum Car {
    TESLA(FEATURES);
    Car(ArrayList l) { }
  }

  public static class Garage {
    final Car car;

    Garage(Car car) {
      this.car = car;
    }
  }

  public static Garage ONE_CAR_GARAGE = new Garage(Car.TESLA);
}

We'll also need a few snippets from a page out of the JLS.

A class or interface type T will be initialized immediately before the first occurrence of any one of the following:

• A static field declared by T is used and the field is not a constant variable (§4.12.4).

 

12.4.2. Detailed Initialization Procedure

...

9. Next, execute either the class variable initializers and static initializers of the class, or the field initializers of the interface, in textual order, as though they were a single block.

So our static data is being initialized when it's first referenced. Now, your Car.TESLA is implicitly static final, but it's not a constant, as per the definition.

A constant variable is a final variable of primitive type or type String that is initialized with a constant expression

So for our purposes, there are three static non-constant variables in play here: FEATURES, TESLA, and ONE_CAR_GARAGE.

Now, in your working case, you reference Recreate.ONE_CAR_GARAGE. This is a reference to a static field in Recreate, so FEATURES and then ONE_CAR_GARAGE get initialized. Then, during the initialization of ONE_CAR_GARAGE, TESLA gets initialized since its enumeration class is referenced. All's well.

However, if we reference the enum too early then we do things in the wrong order. Recreate.Car.TESLA gets referenced, so TESLA gets initialized. TESLA references FEATURES, so Recreate has to be initialized. This causes FEATURES and ONE_CAR_GARAGE to get initialized before TESLA finishes existing.

It's that hidden dependency that trips you up. Recreate.Car depends on Recreate which depends on Recreate.Car. Moving the ONE_CAR_GARAGE field into the Garage class will cause it to not get initialized with FEATURES and will fix your problem.