Bu şekilde beyan edilen bir Liste var :

 List<? extends Number> foo3 = new ArrayList<Integer>();

3 foo3 eklemeye çalıştım. Ancak bu gibi bir hata mesajı alıyorum:

The method add(capture#1-of ? extends Number) in the type List<capture#1-of ?
extends Number> is not applicable for the arguments (ExtendsNumber)

Üzgünüm, ama yapamazsın.

List<? extends Number> foo3 joker Bildirgesi 10 ** değişken tipleri bir aile (belirli bir türde herhangi bir değer yerine herhangi bir değer tutabilir anlamına gelir. Bu herhangi bir yasal işler anlamına gelir:

List<? extends Number> foo3 = new ArrayList<Number>;  // Number "extends" Number
List<? extends Number> foo3 = new ArrayList<Integer>; // Integer extends Number
List<? extends Number> foo3 = new ArrayList<Double>;  // Double extends Number

Bu yüzden, bu göz önüne alındığında, ne tür bir nesnenin List foo3 ekler misiniz ArrayList Olası atamaları yukarıda: herhangi bir yasal olurdu

• foo3 List<Double> bir işaret olabilir çünkü Integer ekleyemezsiniz.
• foo3 List<Integer> bir işaret olabilir çünkü Double ekleyemezsiniz.
• foo3 List<Integer> bir işaret olabilir çünkü Number ekleyemezsiniz.

Yapamazsın eklemek istediğiniz herhangi bir nesneye List<? extends T> çünkü yapamazsın garanti ne tür List gerçekten işaret etmek istiyorum, bu yüzden mi garanti nesne izin List. Sadece" sadece okuyabilir ve T. T veya bir alt alacaksın "garantisi

Ters mantık* örneğin *29 28* *için geçerlidir. Bu yasal

List<? super Number> foo3 = new ArrayList<Number>; // Number is a "super" of Number
List<? super Number> foo3 = new ArrayList<Object>; // Object is a "super" of Number

Gerçekten işaret ne garanti edemezsin çünkü List<? super T> belirli tip T (*31 örneğin*) okuyabilirsiniz. Sadece "var" listesine işaret ediliyor bütünlüğünü ihlal etmeden yazın T (ya da T alt sınıf) değeri ekleyebilirsiniz. garanti

Bu mükemmel bir örnek Collections.copy() imza:

public static <T> void copy(List<? super T> dest,List<? extends T> src)

Fark nasıl src liste bildirimi kullanır extends izin ver pas ver bana herhangi bir listeden bir aile ile ilgili Liste türleri ve hala garanti üretecek değerleri T türü veya alt sınıflar T. Ancak ekleme src listesi.

dest liste bildirimi kullanır super izin ver pas ver bana herhangi bir listeden bir aile ile ilgili Liste türleri ve hala garanti edebilirim yazmak bir değeri belirli bir tür T o liste. Ama ben yapamazsam listeden okursam T değerleri alma garantili.

Şimdi, jenerik joker sayesinde, tek bir yöntem ile bu aramalarıma yapabilirim:

// copy(dest, src)
Collections.copy(new ArrayList<Number>(), new ArrayList<Number());
Collections.copy(new ArrayList<Number>(), new ArrayList<Integer());
Collections.copy(new ArrayList<Object>(), new ArrayList<Number>());
Collections.copy(new ArrayList<Object>(), new ArrayList<Double());

Kafa karıştırıcı ve çok geniş bu kod beyin egzersiz düşünün. Çizgiler yasadışı ve sebebi hattın aşırı sağ (bazılarını görmek için kaydırma gerekir) belirtilmiştir dışarı yorumladı:

  List<Number> listNumber_ListNumber  = new ArrayList<Number>();
//List<Number> listNumber_ListInteger = new ArrayList<Integer>();                    // error - can assign only exactly <Number>
//List<Number> listNumber_ListDouble  = new ArrayList<Double>();                     // error - can assign only exactly <Number>

  List<? extends Number> listExtendsNumber_ListNumber  = new ArrayList<Number>();
  List<? extends Number> listExtendsNumber_ListInteger = new ArrayList<Integer>();
  List<? extends Number> listExtendsNumber_ListDouble  = new ArrayList<Double>();

  List<? super Number> listSuperNumber_ListNumber  = new ArrayList<Number>();
//List<? super Number> listSuperNumber_ListInteger = new ArrayList<Integer>();      // error - Integer is not superclass of Number
//List<? super Number> listSuperNumber_ListDouble  = new ArrayList<Double>();       // error - Double is not superclass of Number


//List<Integer> listInteger_ListNumber  = new ArrayList<Number>();                  // error - can assign only exactly <Integer>
  List<Integer> listInteger_ListInteger = new ArrayList<Integer>();
//List<Integer> listInteger_ListDouble  = new ArrayList<Double>();                  // error - can assign only exactly <Integer>

//List<? extends Integer> listExtendsInteger_ListNumber  = new ArrayList<Number>(); // error - Number is not a subclass of Integer
  List<? extends Integer> listExtendsInteger_ListInteger = new ArrayList<Integer>();
//List<? extends Integer> listExtendsInteger_ListDouble  = new ArrayList<Double>(); // error - Double is not a subclass of Integer

  List<? super Integer> listSuperInteger_ListNumber  = new ArrayList<Number>();
  List<? super Integer> listSuperInteger_ListInteger = new ArrayList<Integer>();
//List<? super Integer> listSuperInteger_ListDouble  = new ArrayList<Double>();     // error - Double is not a superclass of Integer


  listNumber_ListNumber.add(3);             // ok - allowed to add Integer to exactly List<Number>

  // These next 3 are compile errors for the same reason:
  // You don't know what kind of List<T> is really
  // being referenced - it may not be able to hold an Integer.
  // You can't add anything (not Object, Number, Integer,
  // nor Double) to List<? extends Number>      
//listExtendsNumber_ListNumber.add(3);     // error - can't add Integer to *possible* List<Double>, even though it is really List<Number>
//listExtendsNumber_ListInteger.add(3);    // error - can't add Integer to *possible* List<Double>, even though it is really List<Integer>
//listExtendsNumber_ListDouble.add(3);     // error - can't add Integer to *possible* List<Double>, especially since it is really List<Double>

  listSuperNumber_ListNumber.add(3);       // ok - allowed to add Integer to List<Number> or List<Object>

  listInteger_ListInteger.add(3);          // ok - allowed to add Integer to exactly List<Integer> (duh)

  // This fails for same reason above - you can't
  // guarantee what kind of List the var is really
  // pointing to
//listExtendsInteger_ListInteger.add(3);   // error - can't add Integer to *possible* List<X> that is only allowed to hold X's

  listSuperInteger_ListNumber.add(3);      // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>
  listSuperInteger_ListInteger.add(3);     // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>