Définition d'un Enum Java

Question

Je pensais avoir bien compris les génériques de Java, mais je suis tombé sur ce qui suit dans java.lang.Enum :

class Enum<E extends Enum<E>>

Quelqu'un pourrait-il m'expliquer comment interpréter ce paramètre de type ? Des points supplémentaires sont accordés si vous fournissez d'autres exemples d'utilisation d'un paramètre de type similaire.

Answer 1

Cela signifie que l'argument de type de l'enum doit dériver d'un enum qui a lui-même le même argument de type. Comment cela peut-il se produire ? En faisant de l'argument de type le nouveau type lui-même. Donc, si j'ai un enum appelé StatusCode, ce serait équivalent à :

public class StatusCode extends Enum<StatusCode>

Maintenant, si vous vérifiez les contraintes, nous avons Enum<StatusCode> - donc E=StatusCode . Vérifions : est-ce que E étendre Enum<StatusCode> ? Oui ! Nous allons bien.

Vous vous demandez peut-être quel est l'intérêt de tout ceci :) Eh bien, cela signifie que l'API pour Enum peut se référer à elle-même - par exemple, être capable de dire que Enum<E> met en œuvre Comparable<E> . La classe de base est capable de faire les comparaisons (dans le cas des enums) mais elle peut s'assurer qu'elle ne compare que le bon type d'enums entre eux. (EDIT : Enfin, presque - voir l'édition en bas de page).

J'ai utilisé quelque chose de similaire dans mon portage C# de ProtocolBuffers. Il y a des "messages" (immuables) et des "constructeurs" (mutables, utilisés pour construire un message) - et ils sont présentés sous forme de paires de types. Les interfaces concernées sont :

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>

Cela signifie qu'à partir d'un message, vous pouvez obtenir un constructeur approprié (par exemple, pour prendre une copie d'un message et en modifier certains éléments) et à partir d'un constructeur, vous pouvez obtenir un message approprié lorsque vous avez fini de le construire. C'est une bonne chose que les utilisateurs de l'API n'aient pas besoin de s'en préoccuper - c'est horriblement compliqué et il a fallu plusieurs itérations pour en arriver là.

EDIT : Notez que cela ne vous empêche pas de créer des types bizarres qui utilisent un argument de type qui est lui-même correct, mais qui n'est pas le même type. Le but est de donner des avantages dans le droite plutôt que de vous protéger de la mauvais cas.

Donc si Enum ne sont pas traités "spécialement" en Java de toute façon, vous pourriez (comme indiqué dans les commentaires) créer les types suivants :

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

Second mettrait en œuvre Comparable<First> plutôt que Comparable<Second> ... mais First lui-même serait bien.

Answer 2

Ce qui suit est une version modifiée de l'explication du livre. Génériques et collections Java : Nous avons un Enum déclaré

enum Season { WINTER, SPRING, SUMMER, FALL }

qui sera étendu à une classe

final class Season extends ...

donde ... est d'être la classe de base paramétrée pour les Enums. Travaillons ce que cela doit être. Eh bien, l'une des exigences pour Season est qu'il doit mettre en œuvre Comparable<Season> . Donc nous allons avoir besoin

Season extends ... implements Comparable<Season>

Que pourriez-vous utiliser pour ... qui permettrait à cela de fonctionner ? Étant donné qu'il doit s'agir d'un paramétrage de Enum le seul choix est Enum<Season> pour que vous puissiez avoir :

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

Alors Enum est paramétrée sur des types comme Season . Résumé de Season et vous obtenez que le paramètre de Enum est tout type qui satisfait

 E extends Enum<E>

---

Maurice Naftalin (co-auteur, Java Generics and Collections)

Answer 3

Voici l'explication que je préfère : Enum groking (aka Enum<E extends Enum<E>>)

Answer 4

Vous n'êtes pas le seul à vous demander ce que cela signifie, voir Blog de Chaotic Java .

"Si une classe étend cette classe, elle doit passer un paramètre E. Les limites du paramètre E sont pour une classe qui étend cette classe avec le même paramètre E".

Answer 5

Cet article a totalement clarifié pour moi le problème des "types génériques récursifs". Je voulais juste ajouter un autre cas où cette structure particulière est nécessaire.

Supposons que vous ayez des nœuds génériques dans un graphe générique :

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

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

    public Collection<T> getNeighbor();
}

On peut alors avoir des graphes de types spécialisés :

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

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

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