私有实例成员从匿名静态实例访问

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 (ie 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.

Answer 3

Update

It does appear that it is because it is defined in a static block. Take a look at the following:

    private E works = new E("A", 0) {

        public int get() {
            return i; // Compiles
        }
    };

    static {
        A = new E("A", 0) {

            public int get() {
                return i; // Doesn't Compile
            }

        };
    }

---

Original

I compiled the enum and then decompiled it using Jad to see what the code might look like:

static abstract class E extends Enum
{

    public static E[] values()
    {
        return (E[])$VALUES.clone();
    }

    public static E valueOf(String s)
    {
        return (E)Enum.valueOf(Foo$E, s);
    }

    public abstract int get();

    public static final E A;
    private int i;
    private static final E $VALUES[];

    static
    {
        A = new E("A", 0) {

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

        }
;
        $VALUES = (new E[] {
            A
        });
    }


    private E(String s, int j)
    {
        super(s, j);
        i = 0;
        i = 1;
    }

}

This makes it clearer to me that A is an anonymous inner class defined in a static init block of type E . Looking around for private member visibility in anonymous inner classes, I found the following in this answer ( Why are only final variables accessible in anonymous class? ):

When you create an instance of an anonymous inner class, any variables which are used within that class have their values copied in via the autogenerated constructor. This avoids the compiler having to autogenerate various extra types to hold the logical state of the "local variables", as for example the C# compiler does

From this I take it that Ai refers to this copied variable in A, and not i declared in E. The only way to get the i in E is if it is either static or not private.

---

Answer 4

private methods can be accessed in nested classes provided that are in the same class file.

For this reason, the first example works even though A is an anonymous sub-class of E. It is curious as to why the second example doesn't compile, but I suspect it's mis-leading error message as you can do

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

compile but

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

gives

error: non-static variable i cannot be referenced from a static context

which is clearly incorrect given super.i would have no meaning if this were a static context.

As Marko notes

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

produces the error message

error: i has private access in E

which may be more approriate. Ie you can access this field explictly, but not implicitly.