Java枚举协会

Question

我想创建一个场景，其中由enum class A中的枚举常量具有关联的子enum class B和enum class C包含它们自己的常量。 enum class B和enum class C中的常量从enum class D组常量的子集。下面是一个基本上就是我想实现：

enum A { 
    CONST_1 ("const_1", B), // B is the associated enum 
    CONST_2 ("const_2", C); // C in the associated enum 

    private final String strVal; 
    private final Enum associatedEnum; 

    private A (String strVal, Enum associatedEnum) { 
     this.strVal = strVal; 
     this.associatedEnum = associatedEnum; 
    } 

    public Enum getAssociatedEnum() { 
     return this.associatedEnum; 
    } 

    public String toString() { 
     return this.strVal; 
    }  

    // Associated Enum contained subset of grouped constants 
    enum B { 
     CONST_3 (D.CONST_7.toString()), 
     CONST_4 (D.CONST_8.toString()); 

     private final String strVal; 

     private B (String strVal) { 
      this.strVal = strVal; 
     } 

     public String toString() { 
      return this.strVal; 
     }  
    } 

    // Associated Enum contained subset of grouped constants 
    enum C { 
     CONST_5 (D.CONST_9.toString()), 
     CONST_6 (D.CONST_10.toString()); 

     private final String strVal; 

     private C (String strVal) { 
      this.strVal = strVal; 
     } 

     public String toString() { 
      return this.strVal; 
     }    
    } 
} 

// Separate Enum containing all ungrouped constants 
enum D { 
    CONST_7 ("const_7"), 
    CONST_8 ("const_8"); 
    CONST_9 ("const_9"), 
    CONST_10 ("const_10"); 

    private final String strVal; 

    private D (String strVal) { 
     this.strVal = strVal; 
    } 

    public String toString() { 
     return this.strVal; 
    }  
} 

显然，这句法不起作用开箱即用的，因为你无法通过Java中的类这种方式。但任何人都可以提出一种我可以实现这一目标的方法吗？

我希望能用它来验证客户端应用程序中的静态结构化分组。

Answer 1

这应该有希望做你想做的。我已经列出了一个示例用法，它将列出子枚举类型值。

package a.b.c; 


public class EnumsTest { 

    public enum A { 
    A1(B.class), 
    A2(C.class); 

    private final Class<? extends Enum<?>> enumClazz; 

    A(final Class<? extends Enum<?>> enumClazz ) { 
     this.enumClazz = enumClazz; 
    } 

    public Enum<?>[] getSubEnumConstants() { 
     return enumClazz.getEnumConstants(); 
    } 

    /** 
    * @param value 
    * @return Never null 
    * @throws IllegalArgumentException To be consistent with Enum.valueOf() 
    */ 
    public <T> Enum<?> valueOfSubEnum(final String value) throws IllegalArgumentException { 
    for(Enum<?> enumInstance : getSubEnumConstants()) { 
     if(enumInstance.name().equals(value)) { 
     return enumInstance; 
     } 
    } 
    throw new IllegalArgumentException("valueOf for " + enumClazz.getName() + " could not be resoled with the value of " + value); 
    } 

    } 

    public enum B { 
    B1, 
    B2; 
    } 

    public enum C { 
    C1, 
    C2; 
    } 

    public static void main(String[] args) { 

    for(A a : A.values()) { 
     for(Enum<?> enumInstance : a.getSubEnumConstants()) { 
     System.out.println(a.name() + ":" + enumInstance.name()); 
     } 
    } 
    Enum<?> valueOfSubEnum = A.A1.valueOfSubEnum("B2"); 
    System.out.println(valueOfSubEnum.name()); 
    } 
} 

注意：如果要将子类型锁定到特定集合，可以让它们实现一个接口。

Answer 2

您不能用构造函数private B (String strVal, Enum associatedEnum)声明enum A。你可以声明其他枚举枚举，但不是这样。

Answer 3

这对我的作品，但我可能会错过你想达到什么目的：

public enum A { 

    A1(B.B1), 
    A2(C.C2); 

    private final Enum<?> e; 

    private A(Enum<?> e) { 
    this.e = e; 
    } 

    static enum B { 
    B1, 
    B2; 
    } 

    static enum C { 
    C1(D.D1.getId()), 
    C2(D.D2.getId()); 

    private String id; 

    private C(String id) { 
     this.id = id; 
    } 

    } 

} 
enum D { 
    D1("abc"), 
    D2("def"); 

    private final String id; 

    private D(String id) { 
    this.id = id; 
    } 

    public String getId() { 
    return id; 
    } 

}