Визначення Java Enum

Я думав, що я досить добре розумію Java-дженерики, але потім у java.lang.Enum натрапив на таке:

class Enum<E extends Enum<E>>

Може хтось пояснить, як інтерпретувати параметр цього типу? Бонусні бали за надання інших прикладів, де може бути використаний аналогічний параметр типу.

Це означає, що аргумент типу для enum має випливати з enum, який сам має аргумент того ж типу. Як це може статися? Зробивши аргумент типу самим новим типом. Отже, якщо у мене є перелік під назвою StatusCode, це було б рівнозначно:

public class StatusCode extends Enum<StatusCode>

Тепер якщо ви перевірите обмеження, у нас є Enum<StatusCode>- так E=StatusCode. Давайте перевіримо: чи EпоширюєтьсяEnum<StatusCode> ? Так! Ми все в порядку.

Ви, можливо, запитаєте себе, в чому суть цього :) Ну, це означає, що API для Enum може посилатися на себе - наприклад, бути в змозі сказати, що Enum<E>реалізує Comparable<E>. Базовий клас здатний проводити порівняння (у разі перерахунків), але він може переконатися, що він лише порівнює правильний вид перерахунків між собою. (EDIT: Ну, майже - дивіться правки внизу.)

Я використовував щось подібне в моєму C # порту ProtocolBuffers. Існують "повідомлення" (незмінні) та "будівельники" (мутабельні, використовуються для створення повідомлення) - і вони надходять як пари типів. Задіяні інтерфейси:

public interface IBuilder<TMessage, TBuilder>
  where TMessage : IMessage<TMessage, TBuilder> 
  where TBuilder : IBuilder<TMessage, TBuilder>

public interface IMessage<TMessage, TBuilder>
  where TMessage : IMessage<TMessage, TBuilder> 
  where TBuilder : IBuilder<TMessage, TBuilder>

Це означає, що з повідомлення ви можете отримати відповідного конструктора (наприклад, взяти копію повідомлення і змінити деякі біти), а від конструктора ви зможете отримати відповідне повідомлення, коли закінчите його створювати. Корисним робочим користувачам API не потрібно насправді дбати про це - це жахливо складно, і потрібно було кілька ітерацій, щоб дістатися до місця, де він є.

EDIT: Зауважте, що це не заважає вам створювати непарні типи, які використовують аргумент типу, який сам по собі є нормальним, але який не є тим самим. Метою є надання переваг у правильному випадку, а не захист від неправильної справи.

Тож якби Enumдо Java все-таки не зверталися "спеціально", ви могли (як зазначено в коментарях) створити такі типи:

public class First extends Enum<First> {}
public class Second extends Enum<First> {}

Secondбуде реалізовуватись, Comparable<First>а не Comparable<Second>... але Firstсама була б добре.

Далі йде модифікована версія пояснення з книги Java Generics and Collections : У нас є Enumзаявлений

enum Season { WINTER, SPRING, SUMMER, FALL }

який буде розширений до класу

final class Season extends ...

де ...повинен бути якийсь параметризований базовий клас для Enums. Давайте розберемося, що це має бути. Ну, одна з вимог до цього Season- це те, що він повинен реалізовуватися Comparable<Season>. Отже, нам буде потрібно

Season extends ... implements Comparable<Season>

Що б ви могли використовувати для ...цього, що дозволило б це працювати? Зважаючи на те, що це має бути параметризація Enum, єдиний вибір полягає в Enum<Season>тому, щоб ви могли мати:

Season extends Enum<Season>
Enum<Season> implements Comparable<Season>

Так Enumпараметризується на такі типи Season. Абстрактно від Seasonі ви отримуєте, що параметр Enumбудь-якого типу задовольняє

 E extends Enum<E>

Моріс Нафталін (співавтор, Java Generics and Collection)

Це можна проілюструвати простим прикладом та технікою, яка може бути використана для реалізації ланцюгових викликів методів для підкласів. У наведеному нижче прикладі setNameповертає, Nodeтак що ланцюжок не буде працювати для City:

class Node {
    String name;

    Node setName(String name) {
        this.name = name;
        return this;
    }
}

class City extends Node {
    int square;

    City setSquare(int square) {
        this.square = square;
        return this;
    }
}

public static void main(String[] args) {
    City city = new City()
        .setName("LA")
        .setSquare(100);    // won't compile, setName() returns Node
}

Таким чином, ми могли б посилатися на підклас у загальній декларації, щоб Cityтепер повертати правильний тип:

abstract class Node<SELF extends Node<SELF>>{
    String name;

    SELF setName(String name) {
        this.name = name;
        return self();
    }

    protected abstract SELF self();
}

class City extends Node<City> {
    int square;

    City setSquare(int square) {
        this.square = square;
        return self();
    }

    @Override
    protected City self() {
        return this;
    }

    public static void main(String[] args) {
       City city = new City()
            .setName("LA")
            .setSquare(100);                 // ok!
    }
}

Ти не єдиний, хто цікавиться, що це означає; дивіться хаотичний блог Java .

"Якщо клас розширює цей клас, він повинен передавати параметр E. Межі параметра E призначені для класу, який розширює цей клас з тим же параметром E".

Цей пост повністю роз’яснив мені ці проблеми «рекурсивних родових типів». Я просто хотів додати ще один випадок, коли потрібна саме ця структура.

Припустимо, у вас є загальні вузли в загальному графіку:

public abstract class Node<T extends Node<T>>
{
    public void addNeighbor(T);

    public void addNeighbors(Collection<? extends T> nodes);

    public Collection<T> getNeighbor();
}

Тоді ви можете мати графіки спеціалізованих типів:

public class City extends Node<City>
{
    public void addNeighbor(City){...}

    public void addNeighbors(Collection<? extends City> nodes){...}

    public Collection<City> getNeighbor(){...}
}

Якщо ви подивитеся на Enumвихідний код, він має таке:

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {

    public final int compareTo(E o) {
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && // optimization
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }

    @SuppressWarnings("unchecked")
    public final Class<E> getDeclaringClass() {
        Class<?> clazz = getClass();
        Class<?> zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
    }

    public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                                String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    } 
}

По-перше, що E extends Enum<E>означає? Це означає, що параметр типу - це те, що поширюється на Enum, і не параметризується з необробленим типом (параметризується сам по собі).

Це актуально, якщо у вас є перерахунки

public enum MyEnum {
    THING1,
    THING2;
}

на яку, якщо я правильно знаю, перекладається

public final class MyEnum extends Enum<MyEnum> {
    public static final MyEnum THING1 = new MyEnum();
    public static final MyEnum THING2 = new MyEnum();
}

Це означає, що MyEnum отримує такі методи:

public final int compareTo(MyEnum o) {
    Enum<?> other = (Enum<?>)o;
    Enum<MyEnum> self = this;
    if (self.getClass() != other.getClass() && // optimization
        self.getDeclaringClass() != other.getDeclaringClass())
        throw new ClassCastException();
    return self.ordinal - other.ordinal;
}

І ще важливіше,

    @SuppressWarnings("unchecked")
    public final Class<MyEnum> getDeclaringClass() {
        Class<?> clazz = getClass();
        Class<?> zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? (Class<MyEnum>)clazz : (Class<MyEnum>)zuper;
    }

Це робить getDeclaringClass()ролях належнимClass<T> об'єкта.

Більш чітким прикладом є той, на який я відповів на це запитання, де ви не можете уникнути цієї конструкції, якщо ви хочете вказати загальне обмеження.

Згідно з wikipedia, ця закономірність називається цікаво повторюваним шаблоном . В основному, використовуючи схему CRTP, ми можемо легко посилатися на тип підкласу без кастингу типів, а значить, використовуючи шаблон, ми можемо імітувати віртуальну функцію.