¿Qué sería diferente en Java si la declaración Enum no tenía la parte recursiva

Question

Por favor, vea Java Enum definition y Why in java enum is declared as Enum<E extends Enum<E>> para una discusión general. Aquí me gustaría saber cuál sería rota (no Typesafe más, o que requieren moldes adicionales, etc.) si la clase Enum se definió como

public class Enum<E extends Enum> 

Estoy usando este código para probar mis ideas:

interface MyComparable<T> { 
    int myCompare(T o); 
} 

class MyEnum<E extends MyEnum> implements MyComparable<E> { 
    public int myCompare(E o) { return -1; } 
} 

class FirstEnum extends MyEnum<FirstEnum> {} 

class SecondEnum extends MyEnum<SecondEnum> {} 

Con él no pude encontrar ningún beneficio en este caso exacto.

PS. el hecho de que no se me permite hacer

class ThirdEnum extends MyEnum<SecondEnum> {} 

cuando MyEnum se define con la recursividad es
a) no es relevante, ya que con enumeraciones reales no se le permite hacer eso sólo porque no se puede extender enumeración usted mismo
b) no es verdad - pls intentarlo en un compilador y ver que de hecho es capaz de compilar sin errores

PPS. Cada vez me inclino más a creer que la respuesta correcta sería "nada cambiaría si eliminas la parte recursiva", pero no puedo creerlo.

Answer 1

Creo que una razón de peso para hacerlo es que hace que el código en la clase MyEnum sea más seguro.

consideran que la parte recursiva hace posible tal cosa:

class MyEnum<E extends MyEnum<E>> { 
    private Thing<E> util1() { return someObject } 
    private void util2(E e) {} 
    public int method(E o) { 
     Thing<E> thingy = o.util1(); 
     // You can call the util1 method on o and get a type safe return element. 
     E o1 = // I don't care how you get a parametrized E object. 
     o.util2(o1); 
     // You can call the util2 method with a typesafe parameter. 
    } 
} 

En resumen, que la recursividad le permite poner métodos typesafe en la clase de enumeración que puede llamar en cualquier elemento E, y estas llamadas se tipo seguro.

Answer 2

Considera Enum<E>.compareTo(E other).

Que:

• necesita trabajar con E en lugar de enumeración de manera que usted no intenta comparar un valor de enumeración con un valor de una enumeración diferente
• necesita ser capaz de obtener el ordinal valor de la enumeración, a través del método ordinal()declarado en Enum.

¿Cómo propones hacer ese trabajo sin la restricción actual?

Esa es solo la primera que se me ocurrió ... Estoy seguro de que hay muchas otras. Básicamente es una forma de decir: "No intente tratar todas las enumeraciones como equivalentes entre sí ... una enumeración es un conjunto cerrado en sí mismo, pero todas las enums comparten ciertas propiedades".

Answer 3

Bueno, primero de todo es que se queja de utilizar el tipo de crudo, pero que podría ser:

public class Enum<E extends Enum<?>> 

para el mismo efecto.

Además, con este tipo de genérico que podría hacer algo como:

class FirstEnum extends MyEnum<SecondEnum> { 
} 

class SecondEnum extends MyEnum<FirstEnum> { 
} 

la que me parece que podría dar lugar a un montón de problemas. Más exactamente, no puede comparar una enumeración de tipo FirstEnum con una enumeración del mismo tipo, tiene que compararla con una enumeración del otro tipo, lo cual es realmente problemático si tiene un List<FirstEnum> que desea ordenar.El ejemplo no se compilará si configuro E en su lugar o ? ya que SecondEnum no es del tipo E extends MyEnum<E> (esto daría lugar a una herencia circular). Sin embargo, funcionará si FirstEnum extends MyEnum<FirstEnum> (lo que significa que SecondEnum es una clase hija de FirstEnum - herencia jerárquica normal).

Answer 4

Si no tiene el parámetro de tipo genérico, no podrá ampliar Comparable<T extends Comparable> para el subtipo específico de enumeración que ha creado.

Se podía ignorar esto, y crear su propio tipo MyEnum que se comporta de la misma, pero sin la restricción de que diferentes MyEnum no son comparables:

public abstract class MyEnum implements Comparable<MyEnum> 
{ 
    private final int ordinal; 

    protected MyEnum (int ordinal) 
    { 
     this.ordinal = ordinal; 
    } 

    public int ordinal() 
    { 
     return ordinal ; 
    } 

    public int compareTo (MyEnum other) 
    { 
     return ordinal - other.ordinal; // ignore overflow for now 
    } 

    public boolean equals (Object other) { 
     return ordinal == ((MyEnum)other).ordinal; 
    } 

    public int hashCode() { 
     return ordinal; 
    } 
} 

Esto se comporta de la misma manera que una enumeración haría para las operaciones definidas, pero en lugar de ser una implementación segura de tipo genérico obedece a LSP - los objetos de diferentes subclases de MyEnum son comparables o iguales entre sí si tienen el mismo valor ordinal.

public static class EnumA extends MyEnum 
{ 
    private EnumA (int ordinal) { super (ordinal); } 
    public static final EnumA a = new EnumA (0); 
    public static final EnumA b = new EnumA (1); 
} 

public static class EnumB extends MyEnum 
{ 
    private EnumB (int ordinal) { super (ordinal); } 
    public static final EnumB x = new EnumB (0); 
    public static final EnumB y = new EnumB (1); 
} 

public static void main (String...args) 
{ 
    System.out.println (EnumA.a.compareTo (EnumB.x)); 
    System.out.println (EnumA.a.equals (EnumB.x)); 
    System.out.println (EnumA.a.compareTo (EnumB.y)); 
    System.out.println (EnumA.a.equals (EnumB.y)); 
} 

En este caso, si no se sobreescribe equals, se pierde la convención que implica x.comparesTo(y)=0x.equals(y); si anula Igual, entonces hay casos en que x.equals(y) no implica x == y (como para otros objetos de valor), mientras que para las enumeraciones Java ambas pruebas de igualdad producen el mismo resultado.

Answer 5

`X extends Enum<Y>` 

sería ilegal. que es relavant. el compilador puede tener reglas especiales con enum, pero ¿por qué no tener una declaración de tipo perfecto si es posible?