Private instance member access from anonymous static instance

Question

Consider the following code:

enum E {
    A { public int get() { return i; } },
    B { public int get() { return this.i; } },
    C { public int get() { return super.i; } },
    D { public int get() { return D.i; } };

    private int i = 0;
    E() { this.i = 1; }
    public abstract int get();
}

I get compile-time errors on the first 2 enum constants declarations (A & B) but the last 2 compile fine (C & D). The errors are:

Error 1 on line A: non-static variable i cannot be referenced from a static context
Error 2 on line B: i has private access in E

Since get is an instance method, I don't understand why I can't access the instance variable i the way I want.

Note: removing the private keyword from the declaration of i also makes the code compilable, which I don't understand either.

Using Oracle JDK 7u9.

EDIT

As pointed out in the comments, this is not specific to enums and the code below produces the same behaviour:

class E {
    static E a = new E() { public int get() { return i; } };
    static E b = new E() { public int get() { return this.i; } };
    static E c = new E() { public int get() { return super.i; } };
    static E d = new E() { public int get() { return d.i; } };

    private int i = 0;
}

Answer 1

The observed behavior is mandated by the Java Language Specification, in particular implicit access to fields of enclosing types, and the rule that private members are not inherited.

unqualified field access

A { public int get() { return i; } }

The spec mandates:

The optional class body of an enum constant implicitly defines an anonymous class declaration (§15.9.5) that extends the immediately enclosing enum type. The class body is governed by the usual rules of anonymous classes; in particular it cannot contain any constructors.

This makes the expression i somewhat ambiguous: Are we referring to the field of the enclosing instance, or the inner instance? Alas, the inner instance doesn't inherit the field:

Members of a class that are declared private are not inherited by subclasses of that class.

Therefore, the compiler concludes we mean to access the field of the enclosing instance - but being in a static block, there is no enclosing instance, hence the error.

field access through this

B { public int get() { return this.i; } },

The spec mandates:

When used as a primary expression, the keyword this denotes a value that is a reference to the object for which the instance method was invoked (§15.12), or to the object being constructed.

Therefore, it is quite clear we want the field of the inner class, not the outer one.

The reason the compiler rejects the field access expression this.i is:

Members of a class that are declared private are not inherited by subclasses of that class.

That is, a private field can only be accessed through a reference of the type that declares the field, not a subtype thereof. Indeed,

B { public int get() { return ((E)this).i; } },

compiles just fine.

access through super

Like this, super refers to the object the method was invoked on (or the object being constructed). It is therefore clear we mean the inner instance.

Additionally, super is of type E, and the declaration therefore visible.

access through other field

D { public int get() { return D.i; } };

Here, D is an unqualified access to the static field D declared in E. As it is a static field, the question of which instance to use is moot, and the access valid.

It is however quite brittle, as the field is only assigned once the enum object is fully constructed. Should somebody invoke get() during construction, a NullPointerException would be thrown.

Recommendation

As we have seen, accessing private fields of other types is subject to somewhat complex restrictions. As it is rarely needed, developers may be unaware of these subtleties.

While making the field protected would weaken access control (i.e. permit other classes in the package to access the field), it would avoid these issues.

Answer 2

Take a look at this piece of code:

public class E 
{
  final int i;
  private final int j;
  final E a;

  E() { i = j = 0; a = null; }

  E(int p_i) {
    this.i = this.j = p_i;
    a = new E() {
      int getI() { return i; }
      int getJ() { return j; }
    };
  }

  int getI() { throw new UnsupportedOperationException(); }
  int getJ() { throw new UnsupportedOperationException(); }

  public static void main(String[] args) {
    final E ea = new E(1).a;
    System.out.println(ea.getI());
    System.out.println(ea.getJ());
  }
}

this prints

0
1

and the only difference between i and j is the access level!

This is surprising, but it is correct behavior.