Metody statyczne w interfejsach nie działają, jak uzyskać określoną wartość wyliczeniową z kilku wyliczeń?

Question

Mam kilka wyliczeń, które można znaleźć przez int. Odbywa się to metodą statyczną w wyliczeniu. Na przykład:

enum Foo { 
A, B, C, D, ... ; 
    public static Foo fromInt(int i) { 
    switch(i) { 
    case 15: return A; 
    case 42: return B; 
    ... 
} 
} 
enum Bar { 
BLA, BOO, BEE, ... ; 
    public static Bar fromInt(int i) { 
    switch(i) { 
    case 78: return BLA; 
    case 22: return BOO; 
    ... 
} 
} 
... 

Teraz w niektórych kodu Mam ogólny typ T który jest gwarancją jednego z tych teksty stałe i mam całkowitą i. Jak mogę wywołać metodę fromInt i pobrać wystąpienie wyliczenia według wartości i?

Próbowałem stworzyć interfejs za pomocą statycznej metody fromInt i pozwolić, aby enum zaimplementował go, ale statyczne metody nie działają w interfejsach.

nie mogę używać Java 8.

Answer 1

krótka odpowiedź nie można

Długa odpowiedź można też przekazać Class tego wyliczenia do metody i wywołać fromInt przez odbicie lub utworzyć interfejs fabrycznego i wstaw to dla każdego wyliczenia, a następnie przeprowadź właściwą instancję do swojej metody.

Answer 2

Rozszerzanie @talex's answer:

Odbicie:

public class YourEnumFactory { 

    public static <T extends Enum<T>> T get(Class<T> type,int i) { 
    try { 
     return (T) type.getDeclaredMethod("fromInt", int.class).invoke(null, i); 
    } catch (Exception e) { 
     throw new IllegalStateException("Could not find instance of '" + type + "' given '" + i + "'", e); 
    } 
    } 

} 

Fabryki:

public class YourEnumFactory { 

    private interface Factory<T> { 
    T fromInt(int i); 
    } 

    private static final Map<Class<?>, Factory<?>> FACTORIES; 
    static { 
    Map<Class<?>, Factory<?>> factories = new HashMap<>(); 
    factories.put(Foo.class, new Factory<Foo>() { 

     @Override 
     public Foo fromInt(int i) { 
     return Foo.fromInt(i); 
     } 

    }); 
    factories.put(Bar.class, new Factory<Bar>() { 

     @Override 
     public Bar fromInt(int i) { 
     return Bar.fromInt(i); 
     } 

    }); 
    FACTORIES = Collections.unmodifiableMap(factories); 
    } 

    public static <T extends Enum<T>> T get(Class<T> type, int i) { 
    Factory<T> factory = (Factory<T>) FACTORIES.get(type); 
    if (factory != null) { 
     return factory.fromInt(i); 
    } else { 
     throw new InvalidParameterException("No factory for type '" + type + "'"); 
    } 
    } 

} 

Jak zawsze staram się uniknąć refleksji, chciałbym osobiście wybrać to drugie rozwiązanie.

Answer 3

Nie można zrobić to tak, ale chciałbym zrobić to tak:

interface HasId() { 
    public int getId(); 
} 

public class MyRegistry { 
    private static Map<Class<?>, Map<Integer, Object>> REGISTRY = new HashMap<>(); 
    public static <T extends HasId> T fromInt(int id, Class<T> clazz) { 
     return clazz.cast(REGISTRY.getOrDefault(clazz, Collections.emptyMap()).get(id)); 
    } 
    public static void register(HasId obj) { 
     REGISTRY.putIfAbsent(obj.getClass(), new HashMap<>()).put(obj.getId, obj); 
    } 
} 

enum Foo implements HasId { 
    A(15), B(42), C(86), D(99); 
    private final int id; 
    Foo(int id) { 
     this.id = id; 
     MyRegistry.register(this); 
    } 
    public int getId() { 
     return id; 
    } 
} 
// ditto for other enums or non enums as you like 

Następnie użyć:

Foo foo = MyRegistry.fromInt(15, Foo.class); // A 

_{Zastrzeżenie: Kod nie może skompilować lub działać tak jak został zablokowany na moim telefonie (ale jest spora szansa, że ​​zadziała)}