Czy można rozszerzyć enum w Javie 8?

Tutaj są dwa punkty. Konkretnie powodem, dla którego nie kompiluje się jest 8.4.8.1:

Jest to błąd w czasie kompilacji, jeśli instancja nadpisuje statyczną metodę.

Innymi słowy, enum nie może zaimplementować HasValue z powodu zderzenia nazw.

Jest jeszcze bardziej ogólny problem, który polega na tym, że statyczne metody po prostu nie mogą być 'nadpisywane'. Ponieważ valueOf jest statyczną metodą wstawianą przez kompilator na klasę pochodną Enum sam , nie da się tego zmienić. Nie możemy również użyć interfejsów do rozwiązania tego problemu, ponieważ nie mają one metod statycznych.

W tym konkretnym przypadku jest to miejsce, w którym kompozycja może sprawić, że tego typu rzeczy będą mniej powtarzalne, na przykład:

public class ValueOfHelper<E extends Enum<E>> {
    private final Map<String, E> map = new HashMap<String, E>();

    public ValueOfHelper(Class<E> cls) {
        for(E e : EnumSet.allOf(cls))
            map.put(e.name(), e);
    }

    public E valueOfOrNull(String name) {
        return map.get(name);
    }
}

public enum Composed {
    A, B, C;

    private static final ValueOfHelper<Composed> HELPER = (
        new ValueOfHelper<Composed>(Composed.class)
    );

    public static Composed valueOfOrNull(String name) {
        return HELPER.valueOfOrNull(name);
    }
}

(poza tym, i tak polecam, aby złapać wyjątek.)

Zdaję sobie sprawę, że "nie możesz tego zrobić" nie jest tak naprawdę pożądaną odpowiedzią, ale nie widzę sposobu na obejście tego ze względu na statyczny aspekt.

Sprawa jest taka sama, ponieważ nie można utworzyć domyślnego toString() w interfejsie. Enum zawiera już sygnaturę statycznej metody valueOf(String), dlatego nie można jej nadpisać.

Enum są stałą czasową kompilacji i z tego powodu naprawdę wątpliwe, że będą one kiedyś rozszerzalne.

Jeśli chcesz uzyskać stałą poprzez nazwę, możesz użyć tego:

public static <E extends Enum<E>> Optional<E> valueFor(Class<E> type, String name) {

       return Arrays.stream(type.getEnumConstants()).filter( x ->  x.name().equals(name)).findFirst();

    }

Myślę, że mam odpowiedź - jest hacky i używa refleksji, ale wydaje się pasować do briefu - tzn. reverse lookup bez metod w enum i bez rzucania WYJĄTKÓW.

public interface HasName {

    public String name();
}

public interface PoliteEnum extends HasName {

    default String politeName() {
        return name().replace("_", " ");
    }
}

public interface Lookup<P, Q> {

    public Q lookup(P p);
}

public interface ReverseLookup<T extends Enum<T>> extends Lookup<String, T> {

    @Override
    default T lookup(String s) {
        return (T) useMap(this, s);
    }

}

// Probably do somethiong better than this in the final version.
static final Map<String, Enum> theMap = new HashMap<>();

static Enum useMap(Object o, String s) {
    if (theMap.isEmpty()) {
        try {
            // Yukk!!
            Enum it = (Enum)o;
            Class c = it.getDeclaringClass();
            // Reflect to call the static method.
            Method method = c.getMethod("values");
            // Yukk!!
            Enum[] enums = (Enum[])method.invoke(null);
            // Walk the enums.
            for ( Enum e : enums) {
                theMap.put(e.name(), e);
            }
        } catch (Exception ex) {
            // Ewwww
        }
    }
    return theMap.get(s);
}

public enum X implements PoliteEnum, ReverseLookup<X> {

    A_For_Ism,
    B_For_Mutton,
    C_Forth_Highlanders;
}

public void test() {
    for (X x : X.values()) {
        System.out.println(x.politeName());
    }
    for (X x : X.values()) {
        System.out.println(x.lookup(x.name()));
    }
}

Druki

A For Ism
B For Mutton
C Forth Highlanders
A_For_Ism
B_For_Mutton
C_Forth_Highlanders

Dodano

Zainspirowany przez @ Holger - to jest to, co czuję jest najbardziej Jak to, czego szukałem:

public interface ReverseLookup<E extends Enum<E>> extends Lookup<String, E> {

  // Map of all classes that have lookups.
  Map<Class, Map<String, Enum>> lookups = new ConcurrentHashMap<>();

  // What I need from the Enum.
  Class<E> getDeclaringClass();

  @Override
  default E lookup(String name) throws InterruptedException, ExecutionException {
    // What class.
    Class<E> c = getDeclaringClass();
    // Get the map.
    final Map<String, Enum> lookup = lookups.computeIfAbsent(c, 
              k -> Stream.of(c.getEnumConstants())
              // Roll each enum into the lookup.
              .collect(Collectors.toMap(Enum::name, Function.identity())));
    // Look it up.
    return c.cast(lookup.get(name));
  }

}

// Use the above interfaces to add to the enum.
public enum X implements PoliteName, ReverseLookup<X> {

    A_For_Ism,
    B_For_Mutton,
    C_Forth_Highlanders;
}