When a method need to accept an "extensible" set of enum
values, the programmer can apply polymorphism like on a normal class
by creating an interface which will be used anywere where the enum
s shall be used:
public interface ExtensibleEnum {
String name();
}
This way, any enum
tagged by (implementing) the interface can be used as a parameter, allowing the programmer to create a variable amount of enum
s that will be accepted by the method. This can be useful, for example, in APIs where there is a default (unmodifiable) enum
and the user of these APIs want to "extend" the enum
with more values.
A set of default enum values can be defined as follows:
public enum DefaultValues implements ExtensibleEnum {
VALUE_ONE, VALUE_TWO;
}
Additional values can then be defined like this:
public enum ExtendedValues implements ExtensibleEnum {
VALUE_THREE, VALUE_FOUR;
}
Sample which shows how to use the enums - note how printEnum()
accepts values from both enum
types:
private void printEnum(ExtensibleEnum val) {
System.out.println(val.name());
}
printEnum(DefaultValues.VALUE_ONE); // VALUE_ONE
printEnum(DefaultValues.VALUE_TWO); // VALUE_TWO
printEnum(ExtendedValues.VALUE_THREE); // VALUE_THREE
printEnum(ExtendedValues.VALUE_FOUR); // VALUE_FOUR
Note: This pattern does not prevent you from redefining enum values, which are already defined in one enum, in another enum. These enum values would be different instances then.
Also, it is not possible to use switch-on-enum since all we have is the interface, not the real enum
.