Give different variable value to last enum value-CodePudding

I want the last enum to have a different value in one of the variables:

private enum thing {
    thing0(0),
    thing1(1),
    thing2(2);

    int index;
    String s;

    private thing(int index) {
        this.index = index;
        s = index == values().length - 1 ? "b" : "a";
    }
}

This doesn't work; you can't call values() in the constructor. Is there another way?

CodePudding user response：

In general, don't rely on the declaration order of the enum values. Item 35 in Effective Java 3rd Ed, "Use instance fields instead of ordinals", explains why. (Note that whilst you are using an instance field for s, its value depends on the ordinal.)

If you want a particular value to have a particular property, pass it in as a constructor parameter.

private enum thing {
    thing0(0),
    thing1(1),
    thing2(2, "b");

    int index;
    String s;

    private thing(int index) {
        this(index, "a");
    }

    private thing(int index, String s) {
        this.index = index;
        this.s = s;
    }
}

If you really do want it to be checking for the last value in the enum, an alternative way to do this is with a getter. Initialize a static final field in the enum to be the last value:

// Invokes `values()` twice, but meh, it's only executed once.
private static final thing LAST = values()[values().length-1];

Then check in a getter:

String s() {
  return this == LAST ? "b" : "a";
}

CodePudding user response：

There is no need to maintain an index that always matches the ordinal of the enum constant. Further, you can’t rely on the values() array in the constructor as it is supposed to contain the already constructed instances. But to determine, how many constants exist, it is enough to count the associated fields.

public enum Thing {
    thing0,
    thing1,
    thing2;
  
    final String s;
  
    Thing() {
        this.s = ordinal() == numConstants() - 1? "b": "a";
    }
  
    @Override
    public String toString() {
        return name()   "(index = "   ordinal()   ", s = "   s   ")";
    }
  
    private static int NUM_CONSTANTS;
  
    private static int numConstants() {
        int i = NUM_CONSTANTS;
        if(i != 0) return i;
        for(Field f: Thing.class.getDeclaredFields()) if(f.isEnumConstant()) i  ;
        NUM_CONSTANTS = i;
        return i;
    }
}

So System.out.println(EnumSet.allOf(Thing.class)); prints

[thing0(index = 0, s = a), thing1(index = 1, s = a), thing2(index = 2, s = b)]

Note that numConstants() caches the value in NUM_CONSTANTS which is safe as the private method is only invoked within the class initializer. We can’t use a static final variable here, as all custom class initialization will be done after the enum constants have been constructed.