Java Enum определение

Мне показалось, что я достаточно хорошо понимаю дженерики Java, но потом я наткнулся на следующее в java.lang.Enum:

class Enum<E extends Enum<E>>

Может кто-нибудь объяснить, как интерпретировать этот параметр типа? Бонусные баллы за предоставление других примеров использования аналогичного параметра типа.

Это означает, что аргумент типа для enum должен происходить от enum, который сам имеет такой же аргумент типа. Как это может случиться? Делая аргумент типа новым самим типом. Так что если бы у меня был enum с именем StatusCode, это было бы эквивалентно:

public class StatusCode extends Enum<StatusCode>

Теперь, если вы проверите ограничения, у нас есть Enum<StatusCode>- так E=StatusCode. Давайте проверим: Eрасширяется Enum<StatusCode>ли? Да! Мы в порядке.

Вы можете спросить себя, в чем смысл этого :) Ну, это означает, что API для Enum может ссылаться на себя - например, быть в состоянии сказать, что Enum<E>реализует Comparable<E>. Базовый класс может выполнять сравнения (в случае перечислений), но он может убедиться, что он сравнивает только правильные типы перечислений друг с другом. (РЕДАКТИРОВАТЬ: Ну, почти - см. Редактирование внизу.)

Я использовал нечто подобное в моем 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 не нужно на самом деле заботиться об этом - это ужасно сложно и потребовалось несколько итераций, чтобы добраться до места, где он находится.

РЕДАКТИРОВАТЬ: Обратите внимание, что это не мешает вам создавать нечетные типы, которые используют аргумент типа, который сам по себе, но не тот же тип. Цель состоит в том, чтобы дать преимущества в правильном случае, а не защитить вас от неправильного случая.

Таким образом, если бы 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 Collections)

Это можно проиллюстрировать на простом примере и методике, которая может быть использована для реализации связанных вызовов методов для подклассов. В приведенном ниже примере 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, и не параметризован с необработанным типом (он параметризован сам по себе).

Это актуально, если у вас есть 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>объекту.

Более ясный пример - тот, на который я ответил на этот вопрос, где вы не можете избежать этой конструкции, если хотите указать общую границу.

Согласно википедии, этот шаблон называется Curiously recurring template pattern . По сути, используя шаблон CRTP, мы можем легко ссылаться на тип подкласса без приведения типов, что означает, что с помощью шаблона мы можем имитировать виртуальную функцию.