Java Enum Definition

Ich dachte, ich verstehe Java-Generika ziemlich gut, aber dann bin ich in java.lang.Enum auf Folgendes gestoßen:

class Enum<E extends Enum<E>>

Könnte jemand erklären, wie dieser Typparameter zu interpretieren ist? Bonuspunkte für die Bereitstellung anderer Beispiele dafür, wo ein ähnlicher Typparameter verwendet werden könnte.

Dies bedeutet, dass das Typargument für enum von einer Aufzählung abgeleitet werden muss, die selbst dasselbe Typargument hat. Wie kann das passieren? Indem Sie das Typargument zum neuen Typ selbst machen. Wenn ich also eine Aufzählung mit dem Namen StatusCode habe, entspricht dies:

public class StatusCode extends Enum<StatusCode>

Wenn Sie nun die Einschränkungen überprüfen, haben wir Enum<StatusCode>- also E=StatusCode. Lassen Sie uns überprüfen: Everlängert Enum<StatusCode>? Ja! Wir sind okay.

Sie fragen sich vielleicht, worum es geht :) Nun, das bedeutet, dass die API für Enum auf sich selbst verweisen kann - zum Beispiel, wenn Sie sagen können, dass dies Enum<E>implementiert ist Comparable<E>. Die Basisklasse kann die Vergleiche durchführen (im Fall von Aufzählungen), aber sie kann sicherstellen, dass nur die richtige Art von Aufzählungen miteinander verglichen wird. (EDIT: Nun, fast - siehe die Bearbeitung unten.)

Ich habe etwas Ähnliches in meinem C # -Port von ProtocolBuffers verwendet. Es gibt "Nachrichten" (unveränderlich) und "Builder" (veränderlich, zum Erstellen einer Nachricht verwendet) - und sie kommen als Typenpaare. Die beteiligten Schnittstellen sind:

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>

Dies bedeutet, dass Sie aus einer Nachricht einen geeigneten Builder erhalten können (z. B. um eine Kopie einer Nachricht zu erstellen und einige Bits zu ändern), und von einem Builder können Sie eine entsprechende Nachricht erhalten, wenn Sie mit dem Erstellen fertig sind. Es ist ein guter Job, den Benutzer der API nicht wirklich interessieren müssen - es ist schrecklich kompliziert und es dauerte mehrere Iterationen, um dorthin zu gelangen, wo es ist.

BEARBEITEN: Beachten Sie, dass dies Sie nicht davon abhält, ungerade Typen zu erstellen, die ein Typargument verwenden, das selbst in Ordnung ist, aber nicht vom selben Typ ist. Der Zweck besteht darin, Vorteile im richtigen Fall zu bieten, anstatt Sie vor dem falschen Fall zu schützen .

Wenn EnumSie also in Java sowieso nicht "speziell" behandelt würden, könnten Sie (wie in den Kommentaren angegeben) die folgenden Typen erstellen:

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

Secondwürde Comparable<First>eher implementieren als Comparable<Second>... aber Firstselbst wäre in Ordnung.

Das Folgende ist eine modifizierte Version der Erklärung aus dem Buch Java Generics and Collections : Wir haben eine Enumdeklarierte

enum Season { WINTER, SPRING, SUMMER, FALL }

die zu einer Klasse erweitert wird

final class Season extends ...

wo ...soll die irgendwie parametrisierte Basisklasse für Enums sein. Lassen Sie uns herausfinden, was das sein muss. Nun, eine der Anforderungen dafür Seasonist, dass es implementiert werden sollte Comparable<Season>. Also werden wir brauchen

Season extends ... implements Comparable<Season>

Was könnten Sie dafür verwenden ..., damit dies funktioniert? Da es sich um eine Parametrisierung von handeln muss Enum, besteht die einzige Wahl darin Enum<Season>, dass Sie Folgendes haben können:

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

So Enumwird auf Typen wie parametriert Season. Wenn Sie von abstrahieren, erhalten SeasonSie, dass der Parameter von Enumein beliebiger Typ ist, der erfüllt

 E extends Enum<E>

Maurice Naftalin (Co-Autor, Java Generics and Collections)

Dies kann durch ein einfaches Beispiel und eine Technik veranschaulicht werden, mit der verkettete Methodenaufrufe für Unterklassen implementiert werden können. In einem Beispiel unten wird setNameeine zurückgegeben, Nodesodass die Verkettung für Folgendes nicht funktioniert 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
}

Wir könnten also in einer generischen Deklaration auf eine Unterklasse verweisen, sodass die Cityjetzt den richtigen Typ zurückgibt:

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

Sie sind nicht der einzige, der sich fragt, was das bedeutet. Siehe Chaotischer Java-Blog .

"Wenn eine Klasse diese Klasse erweitert, sollte sie einen Parameter E übergeben. Die Grenzen des Parameters E gelten für eine Klasse, die diese Klasse mit demselben Parameter E erweitert."

Dieser Beitrag hat mir dieses Problem der 'rekursiven generischen Typen' vollständig geklärt. Ich wollte nur einen weiteren Fall hinzufügen, in dem diese spezielle Struktur notwendig ist.

Angenommen, Sie haben generische Knoten in einem generischen Diagramm:

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

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

    public Collection<T> getNeighbor();
}

Dann können Sie Diagramme von speziellen Typen haben:

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

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

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

Wenn Sie sich den EnumQuellcode ansehen , hat er Folgendes:

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

Was bedeutet als erstes E extends Enum<E>? Dies bedeutet, dass der Typparameter von Enum ausgeht und nicht mit einem Rohtyp parametrisiert wird (er wird von selbst parametrisiert).

Dies ist relevant, wenn Sie eine Aufzählung haben

public enum MyEnum {
    THING1,
    THING2;
}

was, wenn ich es richtig weiß, übersetzt wird

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

Dies bedeutet, dass MyEnum die folgenden Methoden erhält:

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

Und noch wichtiger:

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

Dadurch wird getDeclaringClass()auf das richtige Class<T>Objekt gegossen .

Ein klareres Beispiel ist das, das ich auf diese Frage beantwortet habe, bei der Sie dieses Konstrukt nicht vermeiden können, wenn Sie eine generische Grenze angeben möchten.

Laut Wikipedia wird dieses Muster als seltsam wiederkehrendes Vorlagenmuster bezeichnet . Grundsätzlich können wir durch Verwendung des CRTP-Musters leicht auf Unterklassentypen ohne Typumwandlung verweisen, was bedeutet, dass wir durch Verwendung des Musters die virtuelle Funktion imitieren können.