Dlaczego Enum miałby implementować interfejs?

Właśnie dowiedziałem się, że Java pozwala enums na implementację interfejsu. Jaki byłby do tego dobry przypadek użycia?

Wyliczenia nie muszą tylko reprezentować zestawów pasywnych (np. Kolorów). Mogą one stanowić więcej obiektów złożonych z funkcjonalnością, a więc jesteś następnie prawdopodobnie chcesz dodać dodatkowej funkcjonalności do nich - na przykład może mieć interfejsy, takie jak Printable, Reportableitd. I komponenty, które obsługują te.

Oto jeden przykład (podobny / lepszy można znaleźć w Effective Java 2nd Edition):

public interface Operator {
    int apply (int a, int b);
}

public enum SimpleOperators implements Operator {
    PLUS { 
        int apply(int a, int b) { return a + b; }
    },
    MINUS { 
        int apply(int a, int b) { return a - b; }
    };
}

public enum ComplexOperators implements Operator {
    // can't think of an example right now :-/
}

Teraz, aby uzyskać listę operatorów Simple + Complex:

List<Operator> operators = new ArrayList<Operator>();

operators.addAll(Arrays.asList(SimpleOperators.values()));
operators.addAll(Arrays.asList(ComplexOperators.values()));

Więc tutaj używasz interfejsu do symulacji rozszerzalnych wyliczeń (co nie byłoby możliwe bez użycia interfejsu).

ComparablePrzykład podany przez kilka osób tu jest nie tak, skoro Enumjuż narzędzia, które. Nie możesz tego nawet przesłonić.

Lepszym przykładem jest interfejs definiujący, powiedzmy, typ danych. Możesz mieć wyliczenie do implementacji prostych typów i mieć normalne klasy do implementowania skomplikowanych typów:

interface DataType {
  // methods here
}

enum SimpleDataType implements DataType {
  INTEGER, STRING;

  // implement methods
}

class IdentifierDataType implements DataType {
  // implement interface and maybe add more specific methods
}

Jest taki przypadek, z którego często korzystam. Mam IdUtilklasę ze statycznymi metodami do pracy z obiektami implementującymi bardzo prosty Identifiableinterfejs:

public interface Identifiable<K> {
    K getId();
}


public abstract class IdUtil {

    public static <T extends Enum<T> & Identifiable<S>, S> T get(Class<T> type, S id) {
        for (T t : type.getEnumConstants()) {
            if (Util.equals(t.getId(), id)) {
                return t;
            }
        }
        return null;
    }

    public static <T extends Enum<T> & Identifiable<S>, S extends Comparable<? super S>> List<T> getLower(T en) {
        List<T> list = new ArrayList<>();
        for (T t : en.getDeclaringClass().getEnumConstants()) {
             if (t.getId().compareTo(en.getId()) < 0) {
                 list.add(t);
            }
        }
        return list;
    }
}

Jeśli utworzę Identifiable enum:

    public enum MyEnum implements Identifiable<Integer> {

        FIRST(1), SECOND(2);

        private int id;

        private MyEnum(int id) {
            this.id = id;
        }

        public Integer getId() {
            return id;
        }

    }

Potem mogę to załatwić w idten sposób:

MyEnum e = IdUtil.get(MyEnum.class, 1);

Ponieważ Enums mogą implementować interfejsy, można ich używać do ścisłego egzekwowania wzorca singletonu. Próba stworzenia standardowej klasy singletonu pozwala ...

• za możliwość wykorzystania technik refleksyjnych do ujawnienia prywatnych metod jako publicznych
• do dziedziczenia po singletonie i zastępowania metod singletona czymś innym

Wyliczenia jako singletony pomagają zapobiegać tym problemom bezpieczeństwa. To mógł być jeden z głównych powodów, dla których Enums działał jak klasy i implementował interfejsy. Tylko zgadnij.

Więcej informacji na stronie /programming/427902/java-enum-singleton i Singleton w java .

Jest to wymagane do rozszerzenia - jeśli ktoś używa API, które opracowałeś, wyliczenia, które definiujesz, są statyczne; nie można ich dodawać ani modyfikować. Jeśli jednak zezwolisz mu na implementację interfejsu, osoba korzystająca z interfejsu API może opracować własne wyliczenie za pomocą tego samego interfejsu. Następnie możesz zarejestrować to wyliczenie za pomocą menedżera wyliczania, który konglomeruje wyliczenia wraz ze standardowym interfejsem.

Edycja: Metoda @Helper ma tego doskonały przykład. Pomyśl o tym, aby inne biblioteki definiowały nowe operatory, a następnie mówiły klasie menedżerów, że „hej, ten enum istnieje - zarejestruj go”. W przeciwnym razie możesz zdefiniować Operatory tylko we własnym kodzie - nie byłoby możliwości rozszerzenia.

Wyliczenia są tylko klasami w przebraniu, więc w większości przypadków wszystko, co możesz zrobić z klasą, możesz zrobić z wyliczeniem.

Nie mogę wymyślić powodu, dla którego wyliczenie nie byłoby w stanie zaimplementować interfejsu, a jednocześnie nie mogę wymyślić żadnego dobrego powodu dla nich.

Powiedziałbym, że kiedy zaczniesz dodawać takie elementy jak interfejsy lub metody do wyliczenia, powinieneś naprawdę rozważyć uczynienie go klasą. Oczywiście jestem pewien, że istnieją uzasadnione przypadki wykonywania nietradycyjnych czynności wyliczeniowych, a ponieważ limit byłby sztuczny, opowiadam się za pozwoleniem ludziom robić to, co chcą.

Na przykład, jeśli masz wyliczenie Logger. Następnie powinieneś mieć w interfejsie metody rejestrujące, takie jak debugowanie, informacje, ostrzeżenie i błąd. Sprawia, że ​​Twój kod jest luźno powiązany.

Najczęstszym zastosowaniem tego byłoby połączenie wartości dwóch wyliczeń w jedną grupę i traktowanie ich w podobny sposób. Na przykład zobacz, jak dołączyć do owoców i warzyw .

Jednym z najlepszych przypadków użycia enum z interfejsem są filtry predykatów. Jest to bardzo elegancki sposób na wyeliminowanie braku typowości kolekcji apache (jeśli nie można użyć innych bibliotek).

import java.util.ArrayList;
import java.util.Collection;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;


public class Test {
    public final static String DEFAULT_COMPONENT = "Default";

    enum FilterTest implements Predicate {
        Active(false) {
            @Override
            boolean eval(Test test) {
                return test.active;
            }
        },
        DefaultComponent(true) {
            @Override
            boolean eval(Test test) {
                return DEFAULT_COMPONENT.equals(test.component);
            }
        }

        ;

        private boolean defaultValue;

        private FilterTest(boolean defautValue) {
            this.defaultValue = defautValue;
        }

        abstract boolean eval(Test test);

        public boolean evaluate(Object o) {
            if (o instanceof Test) {
                return eval((Test)o);
            }
            return defaultValue;
        }

    }

    private boolean active = true;
    private String component = DEFAULT_COMPONENT;

    public static void main(String[] args) {
        Collection<Test> tests = new ArrayList<Test>();
        tests.add(new Test());

        CollectionUtils.filter(tests, FilterTest.Active);
    }
}

W powyższym wpisie wspomniane strategie nie podkreślono wystarczająco dobrze, co zapewnia miła, lekka implementacja wzorca strategii za pomocą wyliczeń:

public enum Strategy {

  A {
    @Override
    void execute() {
      System.out.print("Executing strategy A");
    }
  },

  B {
    @Override
    void execute() {
      System.out.print("Executing strategy B");
    }
  };

  abstract void execute();
}

Możesz mieć wszystkie swoje strategie w jednym miejscu, bez potrzeby oddzielnej jednostki kompilacji dla każdej z nich. Otrzymujesz ładną dynamiczną wysyłkę tylko dzięki:

Strategy.valueOf("A").execute();

Sprawia, że ​​java jest czytana prawie jak ładny luźny język!

Wyliczenia są jak klasy Java, mogą mieć konstruktory, metody itp. Jedyne, czego nie można z nimi zrobić, to new EnumName(). Instancje są predefiniowane w deklaracji wyliczeniowej.

Kolejna możliwość:

public enum ConditionsToBeSatisfied implements Predicate<Number> {
    IS_NOT_NULL(Objects::nonNull, "Item is null"),
    IS_NOT_AN_INTEGER(item -> item instanceof Integer, "Item is not an integer"),
    IS_POSITIVE(item -> item instanceof Integer && (Integer) item > 0, "Item is negative");

    private final Predicate<Number> predicate;
    private final String notSatisfiedLogMessage;

    ConditionsToBeSatisfied(final Predicate<Number> predicate, final String notSatisfiedLogMessage) {
        this.predicate = predicate;
        this.notSatisfiedLogMessage = notSatisfiedLogMessage;
    }

    @Override
    public boolean test(final Number item) {
        final boolean isNotValid = predicate.negate().test(item);

        if (isNotValid) {
            log.warn("Invalid {}. Cause: {}", item, notSatisfiedLogMessage);
        }

        return predicate.test(item);
    }
}

i używając:

Predicate<Number> p = IS_NOT_NULL.and(IS_NOT_AN_INTEGER).and(IS_POSITIVE);

Podczas tworzenia stałych w pliku jar często pomocne jest rozszerzenie wartości wyliczania przez użytkowników. Użyliśmy wyliczeń dla kluczy PropertyFile i utknęliśmy, ponieważ nikt nie mógł dodać żadnych nowych! Poniżej działałoby znacznie lepiej.

Dany:

public interface Color {
  String fetchName();
}

i:

public class MarkTest {

  public static void main(String[] args) {
    MarkTest.showColor(Colors.BLUE);
    MarkTest.showColor(MyColors.BROWN);
  }

  private static void showColor(Color c) {
    System.out.println(c.fetchName());
  }
}

w słoiku można mieć jedno wyliczenie:

public enum Colors implements Color {
  BLUE, RED, GREEN;
  @Override
  public String fetchName() {
    return this.name();
  }
}

a użytkownik może go rozszerzyć, aby dodać własne kolory:

public enum MyColors implements Color {
  BROWN, GREEN, YELLOW;
  @Override
  public String fetchName() {
    return this.name();
  }
}

Oto mój powód, dla którego ...

Zapełniłem JavaFX ComboBox wartościami Enum. Mam interfejs Identyfikowalny (określający jedną metodę: identyfikacja), który pozwala mi określić, w jaki sposób dowolny obiekt identyfikuje się z moją aplikacją do celów wyszukiwania. Ten interfejs umożliwia mi skanowanie list dowolnego rodzaju obiektów (dowolnego pola, którego obiekt może użyć do tożsamości) w celu dopasowania tożsamości.

Chciałbym znaleźć dopasowanie wartości tożsamości na mojej liście ComboBox. Aby skorzystać z tej możliwości w ComboBoxie zawierającym wartości Enum, muszę być w stanie zaimplementować interfejs Identyfikowalny w moim Enum (który, jak się zdarza, jest trywialny w przypadku Enum).

Użyłem wewnętrznego wyliczenia w interfejsie opisującym strategię, aby zachować kontrolę nad instancjami (każda strategia to Singleton).

public interface VectorizeStrategy {

    /**
     * Keep instance control from here.
     * 
     * Concrete classes constructors should be package private.
     */
    enum ConcreteStrategy implements VectorizeStrategy {
        DEFAULT (new VectorizeImpl());

        private final VectorizeStrategy INSTANCE;

        ConcreteStrategy(VectorizeStrategy concreteStrategy) {
            INSTANCE = concreteStrategy;
        }

        @Override
        public VectorImageGridIntersections processImage(MarvinImage img) {
            return INSTANCE.processImage(img);
        }
    }

    /**
     * Should perform edge Detection in order to have lines, that can be vectorized.
     * 
     * @param img An Image suitable for edge detection.
     * 
     * @return the VectorImageGridIntersections representing img's vectors 
     * intersections with the grids.
     */
    VectorImageGridIntersections processImage(MarvinImage img);
}

Fakt, że enum implementuje strategię, jest wygodny, aby pozwolić klasie enum działać jako proxy dla jej zamkniętej instancji. który także implementuje interfejs.

jest to rodzaj strategiiEnumProxy: P kod clent wygląda następująco:

VectorizeStrategy.ConcreteStrategy.DEFAULT.processImage(img);

Jeśli nie zaimplementował interfejsu, byłby to:

VectorizeStrategy.ConcreteStrategy.DEFAULT.getInstance().processImage(img);