Jak mogę wyeliminować zduplikowany Kod Enum?

Liczby abstrakcyjne są potencjalnie bardzo przydatne (i obecnie nie są dozwolone). Ale propozycja i prototyp istnieje, jeśli chcesz lobbować kogoś w Sun, aby go dodać:

Http://freddy33.blogspot.com/2007/11/abstract-enum-ricky-carlson-way.html

Sun RFE:

Http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6570766

Uporządkować kod dave ' a:

public class CodeableEnumHelper {
    public static <E extends CodeableEnum> E getByCode(
        String code, E[] values
    ) {
        for (E e : values) {
            if (e.getCode().equalsIgnoreCase(code)) {
                return e;
            }
        }
        return null;
    }
}

public enum IMType implements CodableEnum {
    ...
    public IMType getByCode(String code) {
        return CodeableEnumHelper.getByCode(code, values());
    } 
}

Lub bardziej efektywnie:

public class CodeableEnumHelper {
    public static <E extends CodeableEnum> Map<String,E> mapByCode(
        E[] values
    ) {
        Map<String,E> map = new HashMap<String,E>();
        for (E e : values) {
            map.put(e.getCode().toLowerCase(Locale.ROOT), value) {
        }
        return map;
    }
}

public enum IMType implements CodableEnum {
    ...
    private static final Map<String,IMType> byCode =
        CodeableEnumHelper.mapByCode(values());
    public IMType getByCode(String code) {
        return byCode.get(code.toLowerCase(Locale.ROOT));
    } 
}

Miałem podobny problem z komponentem lokalizacyjnym, który napisałem. Mój komponent jest przeznaczony do dostępu do zlokalizowanych wiadomości ze stałymi enum, które indeksują się w pakiecie zasobów, nie jest to trudny problem.

Odkryłem, że kopiuję i wklejam ten sam "szablon" kod enum wszędzie. Moim rozwiązaniem, aby uniknąć powielania jest generator kodu, który akceptuje plik konfiguracyjny XML z nazwami stałych enum i konstruktorem args. Wyjściem jest kod źródłowy Javy z zachowania "zduplikowane".

Teraz zachowuję pliki konfiguracyjne i generator, a nie cały zduplikowany kod. Wszędzie, gdzie miałbym kod źródłowy enum, jest teraz plik konfiguracyjny XML. Moje Skrypty kompilacji wykrywają nieaktualne wygenerowane pliki i wywołują generator kodu, aby utworzyć kod enum.

Możesz zobaczyć ten komponent tutaj . Szablon, który kopiowałem i wklejałem jest uwzględniany w arkuszu stylów XSLT. Kod generator uruchamia transformację arkusza stylów. Plik wejściowy jest dość zwięzły w porównaniu z wygenerowanym kodem źródłowym enum.

HTH,
Greg

Niestety, nie wydaje mi się, aby można było to zrobić. Najlepiej będzie, jeśli zrezygnujesz w emums i użyjesz konwencjonalnych rozszerzeń klasy i statycznych członków. W przeciwnym razie przywyknij do powielania tego kodu. Przepraszam.

Utwórz klasę narzędzi bezpiecznych dla typu, która załaduje enums kodem:

Interfejs sprowadza się do:

public interface CodeableEnum {
    String getCode();
}

Klasa użytkowa to:

import java.lang.reflect.InvocationTargetException;


public class CodeableEnumUtils {
    @SuppressWarnings("unchecked")
    public static <T extends CodeableEnum>  T getByCode(String code, Class<T> enumClass) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        T[] allValues = (T[]) enumClass.getMethod("values", new Class[0]).invoke(null, new Object[0]);
        for (T value : allValues) {
            if (value.getCode().equals(code)) {
                return value;
            }
        }
        return null;
}

}

Przypadek testowy demonstrujący użycie:

import junit.framework.TestCase;


public class CodeableEnumUtilsTest extends TestCase {
    public void testWorks() throws Exception {
    assertEquals(A.ONE, CodeableEnumUtils.getByCode("one", A.class));
      assertEquals(null, CodeableEnumUtils.getByCode("blah", A.class));
    }

enum A implements CodeableEnum {
    ONE("one"), TWO("two"), THREE("three");

    private String code;

    private A(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }   
}
}

Teraz powielasz tylko metodę getCode (), a metoda getByCode () znajduje się w jednym miejscu. Może być też miło zawinąć wszystkie wyjątki w jednym RuntimeException:)

Tutaj mam inne rozwiązanie:

interface EnumTypeIF {
String getValue();

EnumTypeIF fromValue(final String theValue);

EnumTypeIF[] getValues();

class FromValue {
  private FromValue() {
  }

  public static EnumTypeIF valueOf(final String theValue, EnumTypeIF theEnumClass) {

    for (EnumTypeIF c : theEnumClass.getValues()) {
      if (c.getValue().equals(theValue)) {
        return c;
      }
    }
    throw new IllegalArgumentException(theValue);
  }
}

Sztuczka polega na tym, że Klasa wewnętrzna może być używana do przechowywania "metod globalnych".

Wygląda na to, że faktycznie implementujesz informacje typu run time. Java udostępnia to jako funkcję językową.

Proponuję sprawdzić RTTI lub reflection.

To chyba niemożliwe. Możesz jednak użyć metody valueOf(String name) enum, jeśli chcesz użyć nazwy wartości enum jako kodu.

A może statyczna metoda generyczna? Możesz użyć go ponownie z poziomu metod getByCode() lub po prostu użyć go bezpośrednio. Ja zawsze user integer ID dla moich enum, więc moja metoda getById () ma tylko do do this: return values () [id]. Jest o wiele szybszy i prostszy.

Jeśli naprawdę chcesz dziedziczyć, nie zapominaj, że możesz zaimplementować wzór enum samodzielnie, jak w starej, złej Javie 1.4 days.

Mniej więcej tak blisko, jak doszedłem do tego, czego chcesz, było stworzenie szablonu w IntelliJ, który "zaimplementowałby" kod generyczny(używając wartości enum (String name)). Nie idealne, ale działa całkiem dobrze.

W twoim konkretnym przypadku, metody getCode() / getByCode(String code) wydają się bardzo zamknięte (eufemistycznie mówiąc) na zachowanie metod toString() / valueOf(String value) dostarczanych przez wszystkie wyliczenia. Dlaczego nie chcesz ich użyć?

Innym rozwiązaniem byłoby nie umieszczanie niczego w samym enum, a po prostu dostarczenie dwukierunkowego kodu mapy Enum dla każdego enum. Możesz np. użyć ImmutableBiMap z kolekcji Google.

W ten sposób nie ma duplikatu kodu w ogóle.

Przykład:

public enum MYENUM{
  VAL1,VAL2,VAL3;
}

/** Map MYENUM to its ID */
public static final ImmutableBiMap<MYENUM, Integer> MYENUM_TO_ID = 
new ImmutableBiMap.Builder<MYENUM, Integer>().
put(MYENUM.VAL1, 1).
put(MYENUM.VAL2, 2).
put(MYENUM.VAL3, 3).
build();

Moim zdaniem byłby to najprostszy sposób, bez refleksji i bez dodawania dodatkowego opakowania do twojego enum.

Tworzysz interfejs, który implementuje Twój enum:

public interface EnumWithId {

    public int getId();

}

Następnie w klasie pomocniczej tworzysz metodę taką jak Ta:

public <T extends EnumWithId> T getById(Class<T> enumClass, int id) {
    T[] values = enumClass.getEnumConstants();
    if (values != null) {
        for (T enumConst : values) {
            if (enumConst.getId() == id) {
                return enumConst;
            }
        }
    }

    return null;
}

Metoda ta może być użyta w następujący sposób:

MyUtil.getInstance().getById(MyEnum.class, myEnumId);