Java sabit değerleri neden genel tür parametrelerine sahip olmamalı?

Java numaralandırmaları harika. Jenerikler de öyle. Elbette hepimiz tür silme nedeniyle ikincisinin sınırlamalarını biliyoruz. Ama anlamadığım bir şey var, Neden böyle bir sıralama oluşturamıyorum:

public enum MyEnum<T> {
    LITERAL1<String>,
    LITERAL2<Integer>,
    LITERAL3<Object>;
}

Bu genel tip parametresi <T>daha sonra çeşitli yerlerde yararlı olabilir. Bir yöntem için genel bir tür parametresi düşünün:

public <T> T getValue(MyEnum<T> param);

Veya enum sınıfının kendisinde bile:

public T convert(Object o);

Daha somut örnek 1

Yukarıdaki örnek bazıları için fazla soyut görünebileceğinden, işte bunu neden yapmak istediğime dair daha gerçek hayattan bir örnek. Bu örnekte kullanmak istiyorum

• Numaralandırmalar, çünkü o zaman sonlu bir özellik anahtarı kümesini numaralandırabilirim
• Jenerikler, çünkü o zaman özellikleri depolamak için yöntem düzeyinde tür güvenliğine sahip olabilirim

public interface MyProperties {
     public <T> void put(MyEnum<T> key, T value);
     public <T> T get(MyEnum<T> key);
}

Daha somut örnek 2

Veri türleri numaram var:

public interface DataType<T> {}

public enum SQLDataType<T> implements DataType<T> {
    TINYINT<Byte>,
    SMALLINT<Short>,
    INT<Integer>,
    BIGINT<Long>,
    CLOB<String>,
    VARCHAR<String>,
    ...
}

Her bir enum değişmezi, açık bir şekilde genel türe göre ek özelliklere sahip olacaktır. <T> sahipken, aynı zamanda bir enum (değişmez, tekli, numaralandırılabilir vb.)

Soru:

Bunu kimse düşünmedi mi? Bu derleyiciyle ilgili bir sınırlama mı? " Enum " anahtar kelimesinin " , JVM için üretilen kodu temsil eden sözdizimsel şeker olarak uygulandığı bu sınırlamayı anlamıyorum.

Bunu bana kim açıklayabilir? Cevap vermeden önce şunu düşünün:

• Genel türlerin silindiğini biliyorum :-)
• Class nesnelerini kullanan geçici çözümler olduğunu biliyorum. Bunlar geçici çözümlerdir.
• Genel türler, uygun olan her yerde derleyici tarafından üretilen tür yayınlarına neden olur (örneğin, convert () yöntemini çağırırken
• <T> genel türü, numaralandırmada olacaktır. Bu nedenle, numaralandırmanın değişmez değerlerinin her birine bağlıdır. Dolayısıyla derleyici, aşağıdaki gibi bir şey yazarken hangi türün uygulanacağını bilirdi.String string = LITERAL1.convert(myObject); Integer integer = LITERAL2.convert(myObject);
• Aynısı T getvalue()yöntemdeki genel tür parametresi için de geçerlidir . Derleyici, çağrı yaparken tür atama uygulayabilirString string = someClass.getValue(LITERAL1)

Bu şimdi JEP-301 Enhanced Enums olarak tartışılmaktadır . JEP'de verilen örnek tam olarak aradığım şey:

enum Argument<X> { // declares generic enum
   STRING<String>(String.class), 
   INTEGER<Integer>(Integer.class), ... ;

   Class<X> clazz;

   Argument(Class<X> clazz) { this.clazz = clazz; }

   Class<X> getClazz() { return clazz; }
}

Class<String> cs = Argument.STRING.getClazz(); //uses sharper typing of enum constant

Ne yazık ki, JEP hala önemli sorunlarla mücadele ediyor: http://mail.openjdk.java.net/pipermail/amber-spec-experts/2017-May/000041.html

Cevap soruda:

tür silme nedeniyle

Bağımsız değişken türü silindiğinden, bu iki yöntemden hiçbiri mümkün değildir.

public <T> T getValue(MyEnum<T> param);
public T convert(Object);

Ancak bu yöntemleri gerçekleştirmek için numaranızı şu şekilde oluşturabilirsiniz:

public enum MyEnum {
    LITERAL1(String.class),
    LITERAL2(Integer.class),
    LITERAL3(Object.class);

    private Class<?> clazz;

    private MyEnum(Class<?> clazz) {
      this.clazz = clazz;
    }

    ...

}

Çünkü yapamazsınız. Ciddi anlamda. Bu, dil spesifikasyonuna eklenebilir. Olmadı. Biraz karmaşıklık katacaktır. Maliyet avantajı, yüksek bir öncelik olmadığı anlamına gelir.

Güncelleme: Şu anda JEP 301: Geliştirilmiş Enums altındaki dile ekleniyor .

ENUM'da işe yaramayan başka yöntemler de var. Ne MyEnum.values()dönecekti?

Peki ya MyEnum.valueOf(String name)?

ValueOf için, derleyicinin aşağıdaki gibi genel bir yöntem yapabileceğini düşünüyorsanız

public static MyEnum valueOf (Dize adı);

diye adlandırmak için MyEnum<String> myStringEnum = MyEnum.value("some string property")bu da işe yaramaz. Mesela ararsan ne olur MyEnum<Int> myIntEnum = MyEnum.<Int>value("some string property")? Bu yöntemin doğru çalışması için uygulanması mümkün değildir, örneğin MyEnum.<Int>value("some double property"), tür silme nedeniyle bir istisna attığınızda veya böyle çağırdığınızda null döndürmek mümkün değildir .

Açıkçası bu her şeyden çok bir problem arayışında bir çözüm gibi görünüyor.

Java numaralandırmasının tüm amacı, benzer özellikleri paylaşan tür örneklerinin bir numaralandırmasını, karşılaştırılabilir String veya Integer temsillerinin ötesinde tutarlılık ve zenginlik sağlayacak şekilde modellemektir.

Bir metin kitabı sıralaması örneğini ele alalım. Bu çok kullanışlı veya tutarlı değil:

public enum Planet<T>{
    Earth<Planet>,
    Venus<String>,
    Mars<Long>
    ...etc.
}

Neden farklı gezegenlerimin farklı genel tür dönüşümlere sahip olmasını isteyeyim? Hangi sorunu çözer? Dil anlamını karmaşıklaştırmayı haklı çıkarıyor mu? İhtiyacım varsa, bu davranış, bunu başarmak için en iyi araç mı?

Ek olarak, karmaşık dönüşümleri nasıl yönetirsiniz?

Örneğin

public enum BadIdea<T>{
   INSTANCE1<Long>,
   INSTANCE2<MyComplexClass>;
}

String IntegerAdı veya sırayı sağlamak için yeterince kolaydır . Ancak jenerikler herhangi bir tür tedarik etmenize izin verir. Dönüşümü nasıl yönetirsiniz MyComplexClass? Şimdi, derleyiciyi genel numaralandırmalara sağlanabilecek sınırlı bir tür alt kümesi olduğunu bilmeye zorlayarak ve çok sayıda programcıdan kaçmış gibi görünen kavrama (Generics) ek karışıklık getirerek iki yapıyı karıştırıyorsunuz.

Çünkü "enum", numaralandırmanın kısaltmasıdır. Bu, kodu daha iyi okunabilir hale getirmek için sıra sayılarının yerine duran bir adlandırılmış sabitler kümesidir.

Bir tür parametreleştirilmiş sabitin amaçlanan anlamının ne olabileceğini anlamıyorum.

Bence temelde Enums örneklenemez

JVM izin verdiyse, T sınıfını nereye ayarlarsınız?

Numaralandırma, her zaman aynı olması veya en azından dinamik olarak değişmeyeceği varsayılan verilerdir.

yeni MyEnum <> ()?

Yine de aşağıdaki yaklaşım faydalı olabilir

public enum MyEnum{

    LITERAL1("s"),
    LITERAL2("a"),
    LITERAL3(2);

    private Object o;

    private MyEnum(Object o) {
        this.o = o;
    }

    public Object getO() {
        return o;
    }

    public void setO(Object o) {
        this.o = o;
    }   
}