Arasındaki farklar nelerdir List, List<?>, List<T>, List<E>, ve List<Object>?

1. Liste

List: ham bir türdür, bu nedenle değildir typesafe. Yalnızca döküm kötü olduğunda bir çalışma zamanı hatası oluşturur. Oyuncular kötü olduğunda derleme zamanı hatası istiyoruz. Kullanılması önerilmez.

2. Liste <?>

List<?>sınırsız bir joker karakterdir. Ama bunun ne için olduğundan emin değilim? Sorunsuz bir şekilde yazdırabilirim List<?>:

public static void test(List<?> list){
    System.out.println(list);   // Works
}

Bir öğeye neden öğe ekleyemiyorum List<?>?

public static void test(List<?> list){
    list.add(new Long(2));     // Error
    list.add("2");             // Error
    System.out.println(list);
}

3. <T> listesi

public static void test(List<T> list){   // T cannot be resolved
    System.out.println(list);
}

Bu sözdizimini anlamıyorum. Böyle bir şey gördüm ve işe yarıyor:

public <T> T[] toArray(T[] a){
    return a;   
}

Bazen, görüyorum <T>, ya <E>, veya <U>, <T,E>. Hepsi aynı mı yoksa farklı bir şey mi temsil ediyorlar?

4. <Nesne>

Bu, "Yöntem test(List<Object>)bağımsız değişken için geçerli değil " hatasını verir List<String>:

public static void test(List<Object> list){
    System.out.println(list);
}

Eğer bunu denemek o zaman "dan List<String>için atılamaz List<Object>" var:

test((List<Object>) names);

Kafam karıştı. Stringbir alt sınıf Object, neden List<String>bir alt sınıf değil List<Object>?

1) Doğru

2) Bunu, öğenin türünü umursamadığınız "salt okunur" liste olarak düşünebilirsiniz. Örneğin, listenin uzunluğunu döndüren bir yöntemle kullanılabilir.

3) T, E ve U aynıdır, ancak insanlar örneğin tip için T, Eleman için E, değer için V ve anahtar için K kullanma eğilimindedir. Derleyen yöntem, belirli bir türde bir dizi aldığını ve aynı türde bir dizi döndürdüğünü söylüyor.

4) Portakal ve elmaları karıştıramazsınız. Bir dize listesini nesne listelerini bekleyen bir yönteme geçirebiliyorsanız Dize listenize bir Nesne ekleyebilirsiniz. (Ve tüm nesneler dize değildir)

Son bölüm için: String, Object'in bir alt kümesi olmasına rağmen, List <String> <Object> Listesinden devralınmamıştır.

Gösterim List<?>"bir şeyin listesi (ama ne demiyorum)" anlamına gelir. İçindeki kod testlistedeki herhangi bir nesne için çalıştığından, bu resmi bir yöntem parametresi olarak çalışır.

Bir type parametresi kullanmak (3. noktanızda olduğu gibi), type parametresinin bildirilmesini gerektirir. Bunun için Java sözdizimi <T>işlevin önüne koymaktır . Bu, yöntem gövdesindeki adları kullanmadan önce bir yönteme resmi parametre adlarını bildirmeye tam olarak benzer.

A'yı List<Object>kabul etmemeye gelince List<String>, bu mantıklıdır çünkü a Stringdeğildir Object; bir alt sınıfıdır Object. Çözüm beyan etmektir public static void test(List<? extends Object> set) .... Ama sonra extends Objectgereksizdir, çünkü her sınıf doğrudan veya dolaylı olarak uzanır Object.

Eğer döküm olamaz nedeni List<String>ile List<Object>bunu kısıtlarını ihlal olanak sağlayacak olmasıdır List<String>.

Aşağıdaki senaryoyu düşünün: Eğer varsa List<String>, yalnızca tür nesneler içermesi gerekir String. (Bu bir finalsınıftır)

Eğer bunu a'ya dökebilirsem, o listeye List<Object>eklememe izin veririm Object, böylece orijinal sözleşmesini ihlal ederim List<String>.

Böylece, genel olarak, sınıf sınıftan Cmiras alırsa P, bunun GenericType<C>da miras olduğunu söyleyemezsiniz GenericType<P>.

Not Zaten bu konuda daha önceki bir cevapta yorum yaptım ama daha da büyümek istedim.

Java bilinmezlerini okumanızı tavsiye ederim. Beyanlarda miras, jenerikler, soyutlamalar ve joker karakterleri oldukça iyi açıklar. http://www.javapuzzlers.com/

Java tarihi bağlamında bunlar hakkında konuşalım;

1. List:

Liste, herhangi bir Nesne içerebileceği anlamına gelir. Liste Java 5.0'dan önceki sürümdeydi; Java 5.0 geriye dönük uyumluluk için List'i tanıttı.

List list=new  ArrayList();
list.add(anyObject);

2. List<?>:

?bilinmeyen Nesne anlamına gelir herhangi bir Nesne değil; joker karakter ?tanıtımı Genel Tür tarafından oluşturulan sorunu çözmek içindir; joker karakterlere bakın ; ancak bu da başka bir soruna neden olur:

Collection<?> c = new ArrayList<String>();
c.add(new Object()); // Compile time error

3. List< T> List< E>

Proje Lib'inizde hiçbir T veya E türünün öncülünde genel Beyan anlamına gelir.

4. List< Object> "Genel jenerik parametreleme" anlamına gelir.

Üçüncü noktanızda "T" çözülemez çünkü bildirilmez, genellikle genel bir sınıf bildirdiğinizde bağlı tip parametresinin adı olarak "T" kullanabilirsiniz , oracle öğreticileri de dahil olmak üzere birçok çevrimiçi örnek "T" type parametresinin adı, örneğin, şöyle bir sınıf bildirdiğinizi varsayalım:

public class FooHandler<T>
{
   public void operateOnFoo(T foo) { /*some foo handling code here*/}

}

FooHandler's operateOnFooYöntemin sınıf bildiriminin kendisinde bildirilen "T" türünde bir değişken beklediğini söylüyorsunuz.

public void operateOnFoos(List<T> foos)

T, E veya U tüm durumlarda type parametresinin tüm tanımlayıcıları sözdizimini kullanan birden fazla tip parametresine bile sahip olabilirsiniz.

public class MyClass<Atype,AnotherType> {}

etkili bir şekilde Sting bir alt nesne türü olmasına rağmen dördüncü ponintinizde, jenerik sınıflarında böyle bir ilişki yoktur , derleyici bakış açısından iki farklı türden List<String>bir alt tür değildir List<Object>, bu en iyi bu blog girişinde açıklanmıştır

teori

String[] yayınlanabilir Object[]

fakat

List<String>kullanılamaz List<Object>.

Uygulama

Listeler için bundan daha incedir, çünkü derleme zamanında bir yönteme iletilen bir List parametresinin türü kontrol edilmez. Yöntem tanımı da söylenebilir List<?>- derleyicinin bakış açısından eşdeğerdir. Bu nedenle OP'nin # 2 numaralı örneği, derleme hataları değil çalışma zamanı hataları verir.

List<Object>Bir yönteme iletilen bir parametreyi dikkatle ele alırsanız, listenin herhangi bir öğesinde tür denetimini zorlamıyorsanız, yönteminizi kullanarak tanımlanmış olabilir, List<Object>ancak aslında List<String>çağrı kodundan bir parametre kabul edebilirsiniz .

C. Yani bu kod derleme veya çalışma zamanı hataları vermeyecek ve aslında (ve şaşırtıcı bir şekilde?) Çalışacaktır:

public static void main(String[] args) {
    List argsList = new ArrayList<String>();
    argsList.addAll(Arrays.asList(args));
    test(argsList);  // The object passed here is a List<String>
}

public static void test(List<Object> set) {
    List<Object> params = new ArrayList<>();  // This is a List<Object>
    params.addAll(set);       // Each String in set can be added to List<Object>
    params.add(new Long(2));  // A Long can be added to List<Object>
    System.out.println(params);
}

B. Bu kod bir çalışma zamanı hatası verecektir:

public static void main(String[] args) {
    List argsList = new ArrayList<String>();
    argsList.addAll(Arrays.asList(args));
    test1(argsList);
    test2(argsList);
}

public static void test1(List<Object> set) {
    List<Object> params = set;  // Surprise!  Runtime error
}

public static void test2(List<Object> set) {
    set.add(new Long(2));       // Also a runtime error
}

C. Bu kod bir çalışma zamanı hatası verecektir ( java.lang.ArrayStoreException: java.util.Collections$UnmodifiableRandomAccessList Object[]):

public static void main(String[] args) {
    test(args);
}

public static void test(Object[] set) {
    Object[] params = set;    // This is OK even at runtime
    params[0] = new Long(2);  // Surprise!  Runtime error
}

B'de, parametre derleme zamanında setyazılmaz List: derleyici bunu olarak görür List<?>. Bir çalışma zamanı hatası var çünkü çalışma zamanında, setiletilen gerçek nesne haline gelir main()ve bu bir List<String>. A List<String>kullanılamaz List<Object>.

C de, parametre bir setgerektirir Object[]. String[]Parametre olarak bir nesne ile çağrıldığında derleme hatası ve çalışma zamanı hatası yoktur . Çünkü String[]oyuncu kadrosu Object[]. Ama aldığı gerçek nesne test()değişmedi String[], değişmedi. Böylece paramsnesne de bir olur String[]. Ve a öğesinin 0 öğesi String[]a Long!

(Umarım burada her şeyim var, akıl yürütmem yanlışsa, toplumun bana söyleyeceğinden eminim. GÜNCELLENDİ: Örnek A'daki kodu güncelledik, böylece yapılan noktayı göstermeye devam ediyor.

Sorun 2, çünkü "System.out.println (set);" "System.out.println (set.toString ())" anlamına gelir; set bir List örneğidir, bu nedenle complier List.toString () öğesini çağırır;

public static void test(List<?> set){
set.add(new Long(2)); //--> Error  
set.add("2");    //--> Error
System.out.println(set);
} 
Element ? will not promise Long and String, so complier will  not accept Long and String Object

public static void test(List<String> set){
set.add(new Long(2)); //--> Error
set.add("2");    //--> Work
System.out.println(set);
}
Element String promise it a String, so complier will accept String Object

Sorun 3: Bu semboller aynı, ancak onlara farklı özellikler verebilirsiniz. Örneğin:

public <T extends Integer,E extends String> void p(T t, E e) {}

Sorun 4: Toplama tip parametresi kovaryansına izin vermiyor. Ancak dizi kovaryansa izin verir.

Haklısın: String, Object'in bir alt kümesidir. String, Object'den daha "kesin" olduğundan, System.out.println () için bir argüman olarak kullanmak üzere onu yayınlamanız gerekir.