Định nghĩa Java Enum

Tôi nghĩ rằng tôi đã hiểu các khái quát về Java khá tốt, nhưng sau đó tôi đã tìm thấy những điều sau đây trong java.lang.Enum:

class Enum<E extends Enum<E>>

Ai đó có thể giải thích làm thế nào để giải thích tham số loại này? Điểm thưởng cho việc cung cấp các ví dụ khác về nơi có thể sử dụng tham số loại tương tự.

Nó có nghĩa là đối số kiểu cho enum phải xuất phát từ một enum mà chính nó có cùng đối số kiểu. Làm thế nào điều này có thể xảy ra? Bằng cách làm cho đối số kiểu chính nó. Vì vậy, nếu tôi có một enum được gọi là StatusCode, nó sẽ tương đương với:

public class StatusCode extends Enum<StatusCode>

Bây giờ nếu bạn kiểm tra các ràng buộc, chúng tôi đã có Enum<StatusCode>- vì vậy E=StatusCode. Hãy kiểm tra: có Emở rộng Enum<StatusCode>không? Đúng! Chúng tôi ổn.

Bạn cũng có thể tự hỏi ý nghĩa của vấn đề này là gì :) Vâng, điều đó có nghĩa là API cho Enum có thể tự tham chiếu - ví dụ, có thể nói rằng Enum<E>thực hiện điều đó Comparable<E>. Lớp cơ sở có thể thực hiện các phép so sánh (trong trường hợp enum) nhưng nó có thể đảm bảo rằng nó chỉ so sánh đúng loại enum với nhau. (EDIT: Chà, gần như - xem phần chỉnh sửa ở phía dưới.)

Tôi đã sử dụng một cái gì đó tương tự trong cổng C # của ProtocolBuffers. Có "thông điệp" (không thay đổi) và "người xây dựng" (có thể thay đổi, được sử dụng để xây dựng một thông điệp) - và chúng có dạng cặp. Các giao diện liên quan là:

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>

Điều này có nghĩa là từ một tin nhắn, bạn có thể có được một nhà xây dựng thích hợp (ví dụ: lấy một bản sao của tin nhắn và thay đổi một số bit) và từ một nhà xây dựng, bạn có thể nhận được một tin nhắn phù hợp khi bạn xây dựng xong nó. Đó là một công việc tốt mà người dùng API không cần thực sự quan tâm về vấn đề này - nó phức tạp khủng khiếp và đã thực hiện một số lần lặp để đến nơi.

EDIT: Lưu ý rằng điều này không ngăn bạn tạo các loại lẻ sử dụng đối số loại mà bản thân nó ổn, nhưng không phải là cùng loại. Mục đích là để cho lợi ích trong đúng trường hợp chứ không phải là bảo vệ bạn khỏi những sai trường hợp.

Vì vậy, nếu Enumkhông được xử lý "đặc biệt" trong Java, bạn có thể (như đã lưu ý trong các nhận xét) tạo các loại sau:

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

Secondsẽ thực hiện Comparable<First>chứ không phải Comparable<Second>... nhưng Firstbản thân nó sẽ ổn thôi.

Sau đây là phiên bản sửa đổi của lời giải thích từ cuốn sách Java Generics and Collection : Chúng tôi có một Enumtuyên bố

enum Season { WINTER, SPRING, SUMMER, FALL }

sẽ được mở rộng thành một lớp

final class Season extends ...

trong đó ...là lớp cơ sở được tham số hóa nào đó cho Enums. Chúng ta hãy tìm ra những gì phải có. Vâng, một trong những yêu cầu Seasonlà nó nên thực hiện Comparable<Season>. Vì vậy, chúng tôi sẽ cần

Season extends ... implements Comparable<Season>

Những gì bạn có thể sử dụng cho ...điều đó sẽ cho phép điều này làm việc? Cho rằng nó phải là một tham số hóa Enum, sự lựa chọn duy nhất là Enum<Season>, để bạn có thể có:

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

Vì vậy, Enumđược tham số hóa trên các loại như Season. Tóm tắt từ Seasonvà bạn nhận được rằng tham số của Enumbất kỳ loại nào thỏa mãn

 E extends Enum<E>

Maurice Naftalin (đồng tác giả, Java Generics and Collection)

Điều này có thể được minh họa bằng một ví dụ đơn giản và một kỹ thuật có thể được sử dụng để thực hiện các cuộc gọi phương thức chuỗi cho các lớp con. Trong một ví dụ dưới đây setNametrả về một Nodechuỗi như vậy sẽ không hoạt động cho 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
}

Vì vậy, chúng ta có thể tham chiếu một lớp con trong một khai báo chung, để Citybây giờ trả về đúng loại:

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

Bạn không phải là người duy nhất tự hỏi điều đó có nghĩa là gì; xem blog Java hỗn loạn .

Nếu một lớp mở rộng lớp này, nó sẽ vượt qua một tham số E. Giới hạn của tham số E dành cho một lớp mở rộng lớp này với cùng tham số E.

Bài đăng này đã hoàn toàn làm rõ cho tôi những vấn đề về 'loại chung đệ quy'. Tôi chỉ muốn thêm một trường hợp khác trong đó cấu trúc cụ thể này là cần thiết.

Giả sử bạn có các nút chung trong biểu đồ chung:

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

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

    public Collection<T> getNeighbor();
}

Sau đó, bạn có thể có đồ thị của các loại chuyên ngành:

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

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

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

Nếu bạn nhìn vào Enummã nguồn, nó có các mục sau:

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

Điều đầu tiên đầu tiên, E extends Enum<E>có nghĩa là gì? Điều đó có nghĩa là tham số loại là thứ gì đó kéo dài từ Enum và không được tham số hóa bằng loại thô (nó được tham số hóa bởi chính nó).

Điều này có liên quan nếu bạn có enum

public enum MyEnum {
    THING1,
    THING2;
}

mà, nếu tôi biết chính xác, được dịch thành

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

Vì vậy, điều này có nghĩa là MyEnum nhận được các phương thức sau:

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

Và thậm chí quan trọng hơn,

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

Điều này làm cho getDeclaringClass()diễn viên đến đúng Class<T>đối tượng.

Một ví dụ rõ ràng hơn là một ví dụ mà tôi đã trả lời cho câu hỏi này , nơi bạn không thể tránh cấu trúc này nếu bạn muốn chỉ định một ràng buộc chung.

Theo wikipedia, mẫu này được gọi là mẫu khuôn mẫu định kỳ . Về cơ bản, bằng cách sử dụng mẫu CRTP, chúng ta có thể dễ dàng tham khảo loại lớp con mà không cần truyền kiểu, có nghĩa là bằng cách sử dụng mẫu, chúng ta có thể bắt chước hàm ảo.