Definición de Java Enum

Pensé que entendía bastante bien los genéricos de Java, pero luego encontré lo siguiente en java.lang.Enum:

class Enum<E extends Enum<E>>

¿Alguien podría explicar cómo interpretar este tipo de parámetro? Puntos de bonificación por proporcionar otros ejemplos de dónde se podría usar un parámetro de tipo similar.

Significa que el argumento de tipo para enum debe derivarse de una enumeración que tiene el mismo argumento de tipo. ¿Cómo puede pasar esto? Al hacer que el argumento de tipo sea el nuevo tipo en sí. Entonces, si tengo una enumeración llamada StatusCode, sería equivalente a:

public class StatusCode extends Enum<StatusCode>

Ahora, si verifica las restricciones, tenemos Enum<StatusCode>, entonces E=StatusCode. Vamos a ver: ¿se Eextiende Enum<StatusCode>? ¡Si! Estamos bien

Puede que se pregunte cuál es el punto de esto :) Bueno, significa que la API de Enum puede referirse a sí misma, por ejemplo, poder decir que se Enum<E>implementa Comparable<E>. La clase base puede hacer las comparaciones (en el caso de las enumeraciones) pero puede asegurarse de que solo compara el tipo correcto de enumeraciones entre sí. (EDITAR: Bueno, casi, vea la edición en la parte inferior).

He usado algo similar en mi puerto C # de ProtocolBuffers. Hay "mensajes" (inmutables) y "constructores" (mutables, utilizados para construir un mensaje), y vienen en pares de tipos. Las interfaces involucradas son:

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>

Esto significa que de un mensaje puede obtener un generador apropiado (por ejemplo, para tomar una copia de un mensaje y cambiar algunos bits) y de un generador puede obtener un mensaje apropiado cuando haya terminado de construirlo. Sin embargo, es un buen trabajo que los usuarios de la API no necesitan preocuparse realmente por esto: es terriblemente complicado y tomó varias iteraciones para llegar a donde está.

EDITAR: tenga en cuenta que esto no le impide crear tipos extraños que utilizan un argumento de tipo que sí está bien, pero que no es del mismo tipo. El propósito es brindar beneficios en el caso correcto en lugar de protegerlo del caso incorrecto .

Entonces, si de Enumtodos modos no se manejó "especialmente" en Java, podría (como se señala en los comentarios) crear los siguientes tipos:

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

Secondimplementaría en Comparable<First>lugar de Comparable<Second>... pero en Firstsí estaría bien.

La siguiente es una versión modificada de la explicación del libro de Java Genéricos y Colecciones : Tenemos un Enumdeclararon

enum Season { WINTER, SPRING, SUMMER, FALL }

que se ampliará a una clase

final class Season extends ...

donde ...será la clase base de alguna manera parametrizada para Enums. Veamos qué tiene que ser eso. Bueno, uno de los requisitos Seasones que debe implementarse Comparable<Season>. Entonces vamos a necesitar

Season extends ... implements Comparable<Season>

¿Qué podrías usar para ...permitir que esto funcione? Dado que tiene que ser una parametrización Enum, la única opción es Enum<Season>, para que pueda tener:

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

Entonces Enumse parametriza en tipos como Season. Resumen de Seasony obtienes que el parámetro de Enumes cualquier tipo que satisfaga

 E extends Enum<E>

Maurice Naftalin (coautor, Java Generics and Collections)

Esto se puede ilustrar con un ejemplo simple y una técnica que se puede utilizar para implementar llamadas a métodos encadenados para subclases. En el siguiente ejemplo, se setNamedevuelve un Nodeencadenamiento que no funcionará para 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
}

Entonces podríamos hacer referencia a una subclase en una declaración genérica, de modo que Cityahora devuelva el tipo correcto:

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!
    }
}

No eres el único que se pregunta qué significa eso; ver el blog caótico de Java .

"Si una clase extiende esta clase, debe pasar un parámetro E. Los límites del parámetro E son para una clase que extiende esta clase con el mismo parámetro E".

Esta publicación me ha aclarado totalmente este problema de 'tipos genéricos recursivos'. Solo quería agregar otro caso donde esta estructura particular es necesaria.

Supongamos que tiene nodos genéricos en un gráfico genérico:

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

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

    public Collection<T> getNeighbor();
}

Entonces puede tener gráficos de tipos especializados:

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

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

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

Si observa el Enumcódigo fuente, tiene lo siguiente:

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);
    } 
}

Lo primero es lo primero, ¿qué E extends Enum<E>significa? Significa que el parámetro de tipo es algo que se extiende desde Enum y no está parametrizado con un tipo sin formato (está parametrizado por sí mismo).

Esto es relevante si tienes una enumeración

public enum MyEnum {
    THING1,
    THING2;
}

que, si lo sé correctamente, se traduce a

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

Esto significa que MyEnum recibe los siguientes métodos:

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;
}

Y aún más importante,

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

Esto hace que se getDeclaringClass()lance al Class<T>objeto adecuado .

Un ejemplo mucho más claro es el que respondí en esta pregunta donde no puede evitar esta construcción si desea especificar un límite genérico.

Según Wikipedia, este patrón se llama patrón de plantilla curiosamente recurrente . Básicamente, al usar el patrón CRTP, podemos referirnos fácilmente al tipo de subclase sin conversión de tipo, lo que significa que al usar el patrón, podemos imitar la función virtual.