为什么我不能从 Java 中的专用枚举值访问静态最终成员

Question

我想知道为什么，虽然在 Java 中执行以下操作是完全有效的

public enum Test {
   VALUE1() {
      public static final String CONST_RELATED_TO_VALUE1 = "constant";
      public static final String OTHER_CONST_RELATED_TO_VALUE1 = "constant";
   },
   VALUE2() {
      public static final String CONST_RELATED_TO_VALUE2 = "constant";
   },
   VALUE3;
}

使用Test.VALUE1.CONST_RELATED_TO_VALUE1 访问常量不起作用。

现在我明白了，VALUE1、VALUE2 等实际上通常都被视为Test 类型的静态最终实例，因此没有这些字段，但理论上这些信息应该在编译时可用，这可以通过little test 轻松验证

     // print types and static members
     for (Object o: Test.values()) {
        System.out.println(o.toString() + ": " + o.getClass());
        for (Field field : o.getClass().getDeclaredFields()) {
            if (java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
                System.out.println("\t" + field);
            }
        }             
     }

导致以下输出

VALUE1: class Test$1                                                                                                                                                                               
        public static final java.lang.String Test$1.CONST_RELATED_TO_VALUE1                                                                                                                
        public static final java.lang.String Test$1.OTHER_CONST_RELATED_TO_VALUE1                                                                                                          
VALUE2: class Test$2                                                                                                                                                                               
        public static final java.lang.String Test$2.CONST_RELATED_TO_VALUE2                                                                                                                
VALUE3: class Test                                                                                                                                                                                 
        public static final Test Test.VALUE1                                                                                                                                    
        public static final Test Test.VALUE2                                                                                                                                    
        public static final Test Test.VALUE3                                                                                                                                    
        private static final Test[] Test.$VALUES

很明显，我们实际上在运行时为VALUE1 和VALUE2 提供了适当的专用子类。但看起来我们丢失有关VALUE1 和VALUE2 的具体类型信息的原因也是编译器为VALUE3 使用的基枚举类Test 生成静态枚举值的方式：所有成员都属于输入Test 并丢弃具体类型。

但是，在我看来，如果编译器只是像这样保留这些类型

        public static final Test$1 Test.VALUE1                                                                                                                                    
        public static final Test$2 Test.VALUE2                                                                                                                                    
        public static final Test Test.VALUE3                                                                                                                                    

所有周围的代码仍然可以工作。此外，我们还可以执行我最初尝试的操作并通过Test.VALUE1 访问CONST_RELATED_TO_VALUE1，这显然是Test$1 类型的实例，而不仅仅是Test，虽然通常应该避免它，但似乎在这种情况下通过实例访问该静态成员非常好。

现在正如许多人正确指出的那样，在左侧使用匿名类不是有效的 Java 代码，而且如果没有一些重大的规范更改，编译器也可能不允许使用。但是，这可以通过使用命名内部类轻松解决，因此我们将拥有

        public static final Test.Value1 Test.VALUE1                                                                                                                                    
        public static final Test.Value2 Test.VALUE2                                                                                                                                    
        public static final Test Test.VALUE3                                                                                                                                    

这甚至为调试提供了一个额外的好处，即内部子类名称清楚地映射到相应的枚举值。

现在我知道必须进行一些小的更改，但是从匿名类到命名类并且不丢弃类型似乎是一个很小的更改，这看起来是一个相当不错的功能，没有简单的方法来模拟它使用覆盖的成员或其他东西。

所以我想知道为什么除了时间之外没有这样实现？我是否在这里遗漏了一些重要的东西，会阻止编译器执行此操作（无论是关于实现复杂性还是类型系统的不可能性），是否只是没有实现它以使其更简单，因为没有时间或类似的东西？

（我主要是在寻找为什么决定从编译器/类型系统的角度来实现它的原因，而不是实际的替代方案，因为肯定有几个，尽管它看起来仍然不错模式）

Answer 1

CONST_RELATED_TO_VALUE1 等静态成员是对应枚举值的匿名类的成员，但不是枚举类本身的成员。与其他匿名类一样，这里的对象VALUE1 被声明为Test 类型，即使它是Test 的匿名子类的一个实例。

因此，您不能通过VALUE1.CONST_RELATED_TO_VALUE1 访问CONST_RELATED_TO_VALUE1，因为VALUE1 是Test 类型的引用，而CONST_RELATED_TO_VALUE1 是匿名子类的成员，但不是Test 的成员。 CONST_RELATED_TO_VALUE1 只能被匿名类的其他成员访问。

如果您想访问在VALUE1 的匿名类中定义的值，您需要有一个枚举类型的方法（例如，m()），该方法可以在枚举对象的匿名类中覆盖，并且返回或以某种方式提供您想要公开的值（通过VALUE1.m()）。

Answer 2

枚举常量是特殊变量，属于它们声明的枚举类型。换言之，引用表达式Test.VALUE1 的类型为Test。 TEST 类型没有定义变量名称 CONST_RELATED_TO_VALUE1，因此您无法访问。

这类似于做

class Parent {
}

class Child extends Parent {
    public Object field = new Object();
}
...
Parent ref = new Child(); 
System.out.println(ref.field); // compilation error

除非您尝试通过引用表达式访问 static 字段。

---

枚举常量的可选体定义了扩展枚举类型的新匿名类。

Answer 3

VALUE1() {
  public static final String CONST_RELATED_TO_VALUE1 = "constant";
  public static final String OTHER_CONST_RELATED_TO_VALUE1 = "constant";
}

是一个扩展Test枚举的匿名类。对于这样的类，我们只能在创建后直接访问它的成员（无需反射），例如：

class Foo{
    public static void main(String[] args) {
        System.out.println(new Foo(){
            public String x = "foo";
        }.x);
    }
}

但是如果我们这样写：

Foo f = new Foo(){
    public String x = "foo";
};
System.out.println(f.x);

我们将收到编译错误，因为 f 的类型为 Foo，它没有声明 x 成员。
这就是您的枚举的问题。你在这里做了什么：

VALUE1() {
  public static final String CONST_RELATED_TO_VALUE1 = "constant";
  public static final String OTHER_CONST_RELATED_TO_VALUE1 = "constant";
}

其实是：

public static final Test VALUE1 = new Test(){
//                  ^^^^^^^^^^^
  public static final String CONST_RELATED_TO_VALUE1 = "constant";
  public static final String OTHER_CONST_RELATED_TO_VALUE1 = "constant";
}

如您所见，VALUE1（和其他枚举常量）的类型为 Test，而不是 Test$1（编译器给出的匿名类的名称）。

为什么选择Test 类型而不是Test$1？嗯，可能是因为变量不能用匿名类型声明（我们不能有Test$1 foo变量）而且所有的枚举类型实际上都编译成简单的类它扩展了 Enum 类，因此必须对其字段（常量）应用相同的规则。