Java Numaralandırma tanımı

Java jeneriklerini oldukça iyi anladığımı düşündüm, ama sonra java.lang.Enum'da aşağıdakilere rastladım:

class Enum<E extends Enum<E>>

Birisi bu tür parametrenin nasıl yorumlanacağını açıklayabilir mi? Benzer bir tip parametresinin nerede kullanılabileceğine dair başka örnekler sağlamak için bonus puanlar.

Bu, enum için tür bağımsız değişkeninin, kendisinin aynı tür bağımsız değişkenine sahip bir enumdan türetmesi gerektiği anlamına gelir. Bu nasıl olabilir? Type bağımsız değişkenini yeni türün kendisi yaparak. Yani StatusCode adlı bir numaralandırma varsa, buna eşdeğer olurdu:

public class StatusCode extends Enum<StatusCode>

Şimdi kısıtlamaları kontrol ederseniz, var Enum<StatusCode>- yani E=StatusCode. Kontrol edelim: Euzanıyor Enum<StatusCode>mu? Evet! Biz iyiyiz.

Kendinize bunun amacının ne olduğunu soruyor olabilirsiniz :) Eh, bu, Enum için API'nin kendisine başvurabileceği anlamına gelir - örneğin, bunu Enum<E>uyguladığını söyleyebilmek Comparable<E>. Temel sınıf karşılaştırmaları (numaralandırmalar durumunda) yapabilir, ancak yalnızca doğru türdeki numaralandırmaları birbirleriyle karşılaştırdığından emin olabilir. (DÜZENLEME: Neredeyse - alttaki düzenlemeye bakın.)

ProtocolBuffers benim C # port benzer bir şey kullandım. "Mesajlar" (değişmez) ve "yapıcılar" (değişebilir, bir mesaj oluşturmak için kullanılır) vardır ve bunlar bir tür çift olarak gelir. İlgili arayüzler:

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>

Bu, bir mesajdan uygun bir oluşturucu alabileceğiniz (örneğin bir mesajın kopyasını alıp bazı bitleri değiştirmek için) ve bir oluşturucudan oluşturmayı bitirdiğinizde uygun bir mesaj alabileceğiniz anlamına gelir. API kullanıcılarının iyi bir iş olmasına rağmen aslında bunu önemsemelerine gerek yok - korkunç derecede karmaşık ve bulunduğu yere ulaşmak için birkaç iterasyon aldı.

DÜZENLEME: Bunun, kendisinin iyi olduğu, ancak aynı tür olmayan bir tür bağımsız değişkeni kullanan tek türler oluşturmanızı engellemediğini unutmayın. Amaç, sizi yanlış davadan korumak yerine doğru davada fayda sağlamaktır .

Dolayısıyla Enum, Java'da "özel olarak" ele alınmadıysa, (yorumlarda belirtildiği gibi) aşağıdaki türleri oluşturabilirsiniz:

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

Seconduygulamak Comparable<First>yerine Comparable<Second>... ama Firstkendisi iyi olurdu.

Aşağıdaki kitaptan açıklama değiştirilmiş bir versiyonu , Java Jenerik ve Koleksiyonlar : Biz var Enumdeklare

enum Season { WINTER, SPRING, SUMMER, FALL }

bir sınıfa genişletilecek

final class Season extends ...

...Enum'lar için bir şekilde parametrelendirilen temel sınıf nerede olacak. Bunun ne olması gerektiğine bakalım. Bunun için şartlardan biri de Seasonuygulanması gerektiğidir Comparable<Season>. Yani ihtiyacımız olacak

Season extends ... implements Comparable<Season>

Bunun ...çalışmasına izin vermek için ne kullanabilirsiniz ? Bunun bir parametrelendirmesi olması gerektiği göz önüne alındığında Enum, tek seçenek şudur Enum<Season>:

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

Yani Enumgibi türlerde parametrelendirilir Season. Dan Özet Seasonve parametre olsun Enumher türlü tatmin olmasıdır

 E extends Enum<E>

Maurice Naftalin (ortak yazar, Java Generics and Collections)

Bu, basit bir örnek ve alt sınıflar için zincirleme yöntem çağrılarını uygulamak için kullanılabilecek bir teknikle açıklanabilir. Aşağıdaki örnekte setName, bir Nodezincirleme şunlar için çalışmaz 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
}

Böylece, genel bir bildirimde bir alt sınıfa başvurabiliriz, böylece Cityşimdi doğru türü döndürür:

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

Bunun ne anlama geldiğini merak eden tek kişi sen değilsin; bkz. Kaotik Java blogu .

“Bir sınıf bu sınıfı genişletirse, E parametresini geçmelidir. E parametresinin sınırları, bu sınıfı aynı E parametresiyle genişleten bir sınıf içindir”.

Bu yazı bana 'yinelemeli jenerik tipler' sorununu açıklığa kavuşturdu. Bu özel yapının gerekli olduğu başka bir durum daha eklemek istedim.

Genel bir grafikte genel düğümleriniz olduğunu varsayalım:

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

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

    public Collection<T> getNeighbor();
}

O zaman özel tip grafiklere sahip olabilirsiniz:

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

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

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

EnumKaynak koduna bakarsanız , aşağıdakilere sahiptir:

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

İlk önce, ne anlama E extends Enum<E>geliyor? Bu, type parametresinin Enum'dan uzanan bir şey olduğu ve ham bir türle (kendi başına parametrelendirildiği) parametrelenmediği anlamına gelir.

Bir numaralandırmanız varsa bu önemlidir

public enum MyEnum {
    THING1,
    THING2;
}

ki eğer doğru bilirsem,

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

Bu, MyEnum'un aşağıdaki yöntemleri aldığı anlamına gelir:

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

Ve daha da önemlisi,

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

Bu getDeclaringClass(), uygun Class<T>nesneye döküm yapar .

Daha açık bir örnek, genel bir sınır belirtmek istiyorsanız bu yapıdan kaçınamayacağınız bu soruya cevap verdiğim örnektir .

Vikipedi'ye göre, bu desene merakla tekrar eden şablon deseni denir . Temel olarak, CRTP desenini kullanarak, tip dökümü olmadan alt sınıf tipine kolayca başvurabiliriz, yani deseni kullanarak sanal işlevi taklit edebiliriz.