如何指定枚举构造函数

Question

At present I have a class called TestEnum . In my main method I can work with firstEnum and secondEnum without needing to specify that firstEnum belongs to GroupA and secondEnum belongs to GroupB - the code in TestEnum sorts this out.

Suppose that either firstEnum or secondEnum could be associated with any of the three SubGrouping enum . I want to be able to make this association from within my main method. It is clear I can't use the same approach as with Grouping since GroupA is allocated to firstEnum from within TestEnum .

public enum TestEnum {
    firstEnum (Grouping.GroupA),
    secondEnum (Grouping.GroupB);


    private Grouping group;
    TestEnum(Grouping group) {
        this.group = group;
    } 

    public enum Grouping {
        GroupA, GroupB;
    }
    public enum SubGrouping {
        SubGroup1, SubGroup2, SubGroup3;
    }
}

How do I do this? To be more concrete, it would be good to construct an object such as:

TestEnum enumWithinMainMethod = TestEnum.firstEnum(SubGrouping.SubGroup1)

The desired behaviour of this instance is that it belongs to both SubGroup1 as well as GroupA . Then from such an instance it would be good to have the functionality, for example:

switch(enumWithinMainMethod) {
    case firstEnum:
        // Do something associated with firstEnum
    case secondEnum:
        // Do something associated with secondEnum
    default:
        // ...
}

Answer 1

Double think before going this approach. Enum is aimed to be static, constant and with finite set of values. What you are doing here is making Enum no longer constant (as you are changing/initializing it in runtime).

I believe there are other way to do, for example, review if it is actually required to have the relationship determined in runtime? Can't it be defined in compile-time? You may also having a TestEnum-to-SubGroup map, instead of dynamically construct the content of TestEnum.

Anyway, although it is not preferable, it is technically possible in Java.

Of course you cannot delay the "construction" of enum until your main() logic, but you can have enum constructed as normal, and change the internal state.

// Mind the naming convention
public enum TestEnum {
    FIRST_ENUM(Grouping.GROUP_A),
    SECOND_ENUM (Grouping.GROUP_B);


    private Grouping group;
    private SubGrouping subGrouping;

    TestEnum(Grouping group) {
        this.group = group;
    } 

    public void setSubGrouping(SubGrouping subGrouping) {
        this.subGrouping = subGrouping;
    }

    public enum Grouping {
        GROUP_A, GROUP_B
    }

    public enum SubGrouping {
        SUB_GROUP_1, SUB_GROUP_2, SUB_GROUP_3;
    }
}

Then in your main() , do something like

TestEnum.FIRST_ENUM.setSubGrouping(TestEnum.SubGrouping.SUB_GROUP_1);
TestEnum.SECOND_ENUM.setSubGrouping(TestEnum.SubGrouping.SUB_GROUP_2);

By doing so, you can define the subgrouping of your enum in your main()

Once again, this is NOT PREFERABLE.

Answer 2

You cannot call enum constructors from outside of an enum . You could use a class to get this behaviour.

How about something like this? (The generics are not required, but it does open up the Groupable class to multiple types of groupings.)

public enum Grouping { GroupA, GroupB; }
public enum SubGrouping { SubGroup1, SubGroup2, SubGroup3; }
public class SubGroupable<G extends Enum<G>,S extends Enum<S>> {
    private G mainGroup;
    private S subGroup;
    public Groupable(G group, S subGroup) {
        this.mainGroup = group;
        this.subGroup = subGroup;
    }
    public G getGroup() { return mainGroup; }
    public S getSubGroup() { return subGroup; }
}

Usage

SubGroupable<Grouping, SubGrouping> g 
        = new SubGroupable<>(Grouping.GroupA, SubGrouping.SubGroup2);
switch (g.getGroup()) {
case Grouping.GroupA: 
    //
    break;
case Grouping.GroupB:
    //
    break;
}

You could also create two final groupings:

public final Grouping FIRST_GROUP = Grouping.GroupA;
public final Grouping SECOND_GROUP = Grouping.GroupB;

This way you can use those constants in your case blocks.

switch (g.getGroup()) {
case FIRST_GROUPING: // etc
}