问题描述
我想知道为什么，虽然在Java中执行以下操作是完全有效的
c c VALUE1.CONST_RELATED_TO_VALUE1 code>和 CONST_RELATED_TO_VALUE1 是匿名子类的成员，但不是 Test 的成员。 CONST_RELATED_TO_VALUE1 只能由匿名类的其他成员访问。
如果要访问 VALUE1 的匿名类，您需要有一个枚举类型的方法（例如 m（）覆盖枚举对象的匿名类，并且以某种方式返回或提供您要公开的值（通过 VALUE1.m（））。
I was wondering why, while it's perfectly valid to do the following in 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; }accessing the constants as one would expect using Test.VALUE1.CONST_RELATED_TO_VALUE1 does not work.
Now I understand, VALUE1, VALUE2 etc. are actually all generally seen as static final instance of type Test and hence don't have those fields, but the information should theoretically available at compile time, which can easily be verified running a 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); } } }which results in the following output
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.$VALUESIt's clear that we actually have proper dedicated sub-classes at runtime for VALUE1 and VALUE2. But it also looks like the reason we lose the concrete type information about VALUE1 and VALUE2 is the way the compiler generates the static enum values for the base enum class Test as used by VALUE3: All members are of type Test and the concrete types are discarded.
However, it seems to me that if the compiler simply kept those types like so
public static final Test$1 Test.VALUE1 public static final Test$2 Test.VALUE2 public static final Test Test.VALUE3all surrounding code would still work. In addition we could also do what I tried initially and access CONST_RELATED_TO_VALUE1 through Test.VALUE1, which is now clearly an instance of type Test$1 and not just Test and while it should be generally avoided, it seems in this case perfectly fine to access that static member through an instance.
Now as many people correctly pointed out, using anonymous classes to the left is not valid Java code and probably also for the compiler not allowed without some major specification change. However, this could easily be solved by using named inner classes, so we would have
public static final Test.Value1 Test.VALUE1 public static final Test.Value2 Test.VALUE2 public static final Test Test.VALUE3This even provides an added benefit for debugging that the inner sub class name clearly maps to the corresponding enum value.
Now I understand there would have to be some minor changes, but going from anonymous to named classes and not throwing away the types seems like a small change and this looks like quite a nice feature to have, without an easy way to emulate it using overridden members or something.
So I was wondering why this wasn't implemented like this except time? Am I missing something crucial here that would prevent the compiler from doing this (either regarding implementation complexity or type system impossibilities) was it just not implemented to keep it simpler, because there was no time or something along those lines?
(I'm mainly looking for reasons why it was decided to implement it like this from a compiler/typesystem point of view, not for practical alternatives to this, as there are definitely a couple, though it still seems like a nice pattern to have)
解决方案Static members such as CONST_RELATED_TO_VALUE1 are members of the anonymous class for the corresponding enum value, but not members of the enum class itself. As with other anonymous classes, the object VALUE1 here is declared as being of type Test even though it's an instance of the anonymous subclass of Test.
Therefore, you can't access CONST_RELATED_TO_VALUE1 via VALUE1.CONST_RELATED_TO_VALUE1 because VALUE1 is a reference of type Test and CONST_RELATED_TO_VALUE1 is a member of the anonymous subclass but not of Test. CONST_RELATED_TO_VALUE1 can only be accessed by other members of the anonymous class.
If you want to access values defined in the anonymous class for VALUE1, you need to have a method (say, m()) of the enum type that you override in the anonymous class for the enum object, and that returns or provides somehow the value that you want to expose (via VALUE1.m()).
这篇关于为什么无法从Java中的专用枚举值访问静态final成员的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！