अनुमानित प्रकार एक तुलनीय सामान्य प्रकार के लिए एक वैध विकल्प नहीं है

Question

कोड पर विचार करें:

Bound mismatch: The generic method sort(List< T >) of type Collections is not applicable for the arguments (ArrayList< MyItem< T > >). The inferred type MyItem< T > is not a valid substitute for the bounded parameter < T extends Comparable< ? super T > >

क्यों यह गलत है:

public abstract class Item<T> implements Comparable<T> 
{ 
    protected T item; 

    public int compareTo(T o) 
    { 
     return 0; // this doesn't matter for the time being 
    } 
} 

public class MyItem<T> extends Item<String> 
{ 
    T object; 
} 

public class Foo<T> 
{ 
    protected ArrayList<T> list; 
} 

public class Bar<V> extends Foo<MyItem<V>> 
{ 
    public void sort() 
    { 
     Collections.sort(list); 
    } 
} 

तरह कॉल त्रुटि देता है?

यदि MyItem<V>Comparable लागू करता है तो यह एक विकल्प क्यों नहीं है?

क्षमा करें अगर यह पूछा गया है, लेकिन मुझे लगता है कि सवाल कुछ हद तक विशिष्ट है।

java: no suitable method found for sort(java.util.ArrayList<MyItem<V>>)

method java.util.Collections.<T>sort(java.util.List<T>,java.util.Comparator<? super T>) is not applicable (cannot instantiate from arguments because actual and formal argument lists differ in length)

method java.util.Collections.<T>sort(java.util.List<T>) is not applicable (inferred type does not conform to declared bound(s) inferred: MyItem<V> bound(s): java.lang.Comparable<? super MyItem<V>>)

तो, मुख्य सवाल यह है::

Answer 1

इस त्रुटि के असल में अधिक विस्तृत विवरण अपने javac ही देता है
क्यों है विधि Collections.<T>sort(java.util.List<T>)) लागू नहीं?

जवाब है: <T extends Comparable<? super T>>:
क्योंकि Collections.<T>sort(java.util.List<T>) विधि घोषणा में पैरामीटर T पर सीमा नहीं है।

दूसरे शब्दों में, T को Comparable इंटरफ़ेस को स्वयं पर लागू करना होगा। उदाहरण के लिए String कक्षा इस तरह के इंटरफ़ेस लागू करती है: ...implements ... Comparable<String>।

अपने मामले Item वर्ग में इस तरह के इंटरफ़ेस को लागू नहीं करता है:

Item<T> implements Comparable<T>Item<T> implements Comparable<Item<T>> रूप में एक ही बात नहीं है।

तो, यह समस्या को हल करने के लिए, अपने अपने Item वर्ग इस एक में बदल जानी चाहिए:

public abstract class Item<T> implements Comparable<Item<T>> 
{ 
    protected T item; 

    public int compareTo(Item<T> o) 
    { 
     return 0; // this doesn't matter for the time being 
    } 
} 

Answer 2

आप वर्ग MyItem सिर्फ प्रभाव देखने के लिए generified की आवश्यकता नहीं है। निम्नलिखित वर्ग को देखने के लिए कि क्या होता है पर्याप्त है:

public class MyItem extends Item<String> {} 

अब

आप निम्नलिखित फोन है:

Collections.sort(list); 

Morgano सही ढंग से कहा गया है, प्रकार विधि एक संग्रह है कि एक प्रकार टी के साथ पैरामिट्रीकृत है ले जाएगा यह टी के तुलनीय होना चाहिए। आपकी MyItem कक्षा Item<String> का विस्तार कर रही है, जिसके परिणामस्वरूप MyItemString से तुलनात्मक है।

public abstract class Item<T> { 
    protected T item; 
} 

public class MyItem extends Item<String> implements Comparable<MyItem> { 
    @Override 
    public int compareTo(MyItem o) { 
     return item.compareTo(o.item); // just an example 
    } 
} 

और अब Collections.sort(list) करने के लिए कॉल काम करेगा:

एक छोटे से स्विच जिसमें वर्ग Comparable इंटरफ़ेस लागू करता है के साथ

, आप अपेक्षित परिणाम मिल जाएगा।

Answer 3

बस पालन की तरह वर्ग बदलने के लिए:

 public class MyItem<T> extends Item<String> implement Comparable<MyItem<T>> 
    { 
     T object; 
    } 

या

 public abstract class Item<T> implements Comparable<MyItem<T>> 
     { 
      protected T item; 

      public int compareTo(MyItem<T> o) 
      { 
       return 0; // this doesn't matter for the time being 
     } 

}

त्रुटि युक्तियों से पता चला है us.Hope यह उपयोगी।

Answer 4

प्रकार X की वस्तुओं एक दूसरे के साथ तुलनीय होने के लिए, वर्ग X बिल्कुल Comparable<X> कार्यान्वित करना होगा।

यह वही अपने कोड क्या कर रहा है, तो आप एक वर्ग Item<T> मिल गया है और आप Comparable<Item<T>> के बजाय Comparable<T> कार्यान्वित कर रहे हैं नहीं है। इसका मतलब है कि Item<T> की तुलना T से की जा सकती है, लेकिन Item<T> के साथ नहीं, जो आवश्यक है।

public abstract class Item<T> implements Comparable<Item<T>> 
{ 
    protected T item; 

    @Override 
    public int compareTo(Item<T> o) 
    { 
     return 0; // this doesn't matter for the time being 
    } 
}