Definisi Java Enum

Saya pikir saya memahami generik Java dengan cukup baik, tetapi kemudian saya menemukan yang berikut di java.lang.Enum:

class Enum<E extends Enum<E>>

Bisakah seseorang menjelaskan bagaimana menafsirkan parameter tipe ini? Poin bonus untuk memberikan contoh lain di mana parameter tipe yang sama dapat digunakan.

Ini berarti bahwa argumen tipe untuk enum harus berasal dari enum yang itu sendiri memiliki argumen tipe yang sama. Bagaimana ini bisa terjadi? Dengan membuat argumen type maka tipe baru itu sendiri. Jadi jika saya punya enum yang disebut StatusCode, itu akan setara dengan:

public class StatusCode extends Enum<StatusCode>

Sekarang jika Anda memeriksa kendala, kami punya Enum<StatusCode>- jadi E=StatusCode. Mari kita periksa: apakah Ememperpanjang Enum<StatusCode>? Iya! Kami baik-baik saja

Anda mungkin bertanya pada diri sendiri apa gunanya ini :) Yah, itu berarti bahwa API untuk Enum dapat merujuk pada dirinya sendiri - misalnya, bisa mengatakan Enum<E>implementasinya Comparable<E>. Kelas dasar dapat melakukan perbandingan (dalam hal enum) tetapi dapat memastikan bahwa itu hanya membandingkan jenis enum yang tepat satu sama lain. (EDIT: Ya, hampir - lihat hasil edit di bagian bawah.)

Saya telah menggunakan sesuatu yang serupa di porta C # dari ProtocolBuffers. Ada "pesan" (tidak berubah) dan "pembangun" (bisa berubah, digunakan untuk membangun pesan) - dan mereka datang sebagai pasangan jenis. Antarmuka yang terlibat adalah:

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>

Ini berarti bahwa dari pesan Anda bisa mendapatkan pembangun yang sesuai (misalnya untuk mengambil salinan pesan dan mengubah beberapa bit) dan dari pembangun Anda bisa mendapatkan pesan yang sesuai ketika Anda selesai membangunnya. Ini adalah pekerjaan yang baik, pengguna API tidak perlu benar-benar peduli tentang ini - ini sangat rumit, dan butuh beberapa iterasi untuk sampai ke tempatnya.

EDIT: Perhatikan bahwa ini tidak menghentikan Anda dari membuat tipe aneh yang menggunakan argumen tipe yang itu sendiri tidak apa-apa, tetapi yang bukan tipe yang sama. Tujuannya untuk memberi manfaat dengan benar kasus yang daripada melindungi Anda dari kasus yang salah .

Jadi jika Enum tidak ditangani "khusus" di Java, Anda dapat (seperti tercantum dalam komentar) membuat jenis berikut:

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

Secondakan menerapkan Comparable<First>daripada Comparable<Second>... tapi Firstitu sendiri akan baik-baik saja.

Berikut ini adalah versi penjelasan yang dimodifikasi dari buku Java Generics and Collections : Kami telah Enummendeklarasikannya

enum Season { WINTER, SPRING, SUMMER, FALL }

yang akan diperluas ke kelas

final class Season extends ...

di mana ...menjadi kelas dasar entah bagaimana parameter untuk Enums. Mari kita cari tahu apa yang harus terjadi. Nah, salah satu syaratnya Seasonadalah harus diterapkan Comparable<Season>. Jadi kita perlu

Season extends ... implements Comparable<Season>

Apa yang bisa Anda gunakan untuk ...memungkinkan ini berfungsi? Mengingat bahwa itu harus menjadi parameterisasi Enum, satu-satunya pilihan adalah Enum<Season>, sehingga Anda dapat memiliki:

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

Jadi Enumparameterisasi pada jenis suka Season. Abstrak dari Seasondan Anda mendapatkan bahwa parameter Enumadalah jenis apa pun yang memuaskan

 E extends Enum<E>

Maurice Naftalin (penulis bersama, Java Generics and Collections)

Ini dapat diilustrasikan dengan contoh sederhana dan teknik yang dapat digunakan untuk mengimplementasikan panggilan metode berantai untuk sub-kelas. Dalam contoh di bawah ini, setNamepengembalian Noderantai tidak akan berfungsi untuk 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
}

Jadi kita bisa mereferensikan sub-kelas dalam deklarasi generik, sehingga Citysekarang mengembalikan tipe yang benar:

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

Anda bukan satu-satunya yang bertanya-tanya apa artinya itu; lihat blog Java Chaotic .

"Jika kelas memperluas kelas ini, itu harus melewati parameter E. Batas E parameter adalah untuk kelas yang memperluas kelas ini dengan parameter E yang sama".

Posting ini benar-benar menjelaskan kepada saya masalah 'tipe generik rekursif' ini. Saya hanya ingin menambahkan kasus lain di mana struktur khusus ini diperlukan.

Misalkan Anda memiliki node generik dalam grafik generik:

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

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

    public Collection<T> getNeighbor();
}

Maka Anda dapat memiliki grafik jenis khusus:

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

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

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

Jika Anda melihat Enumkode sumber, ia memiliki yang berikut ini:

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

Hal pertama yang pertama, apa E extends Enum<E>artinya? Itu berarti parameter tipe adalah sesuatu yang memanjang dari Enum, dan tidak diparametisasi dengan tipe mentah (itu diparametisasi dengan sendirinya).

Ini relevan jika Anda memiliki enum

public enum MyEnum {
    THING1,
    THING2;
}

yang, jika saya tahu benar, diterjemahkan ke

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

Jadi ini berarti bahwa MyEnum menerima metode berikut:

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

Dan yang lebih penting,

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

Ini membuat getDeclaringClass()gips ke Class<T>objek yang tepat .

Contoh cara yang lebih jelas adalah yang saya jawab pada pertanyaan ini di mana Anda tidak dapat menghindari konstruk ini jika Anda ingin menentukan batasan umum.

Menurut wikipedia, pola ini disebut pola templat berulang yang menarik . Pada dasarnya, dengan menggunakan pola CRTP, kita dapat dengan mudah merujuk ke tipe subclass tanpa tipe casting, yang berarti dengan menggunakan pola, kita dapat meniru fungsi virtual.