Hi Amir,
We will first define a generic class say MyList;
class Person implements Comparable<Person> {
public int compareTo(Person p1) {
return name.compareTo(p1.name);
}
private String name;
}
public class MyList<T extends Comparable> {
void add(T a) {
}
public static void main(String[] args) {
}
}
We have a generic MyList that can be parameterized with any class that implements Comparable interface. Yeah we have Person class that suits to it. Ok inside the main() method we do like this:
MyList<Person> list1 = new MyList<Person>();//good
Parameterized type Person is a good substitute for what exactly our generic class definition of MyList permits. Although all wrapper classes can substitute the Person as well because they all implement the Comparable interface, but we pay attention to non-standard classes that are our own as Person.
Ok lets extend our activity by making one more class say Driver that extends Person
class Driver extends Person {
}
Obviously Driver class implements the Comparable interface because its daddy implements so. Now the big gotcha: See this
MyList<Driver> mylist1 = new MyList<Driver>();
//Unfortunately you are not allowed to do so. MyList expects here that Driver do also implement the Comparable interface, inheritance of interface implementation from the Parent class wont do here. Don�t you feel it�s overkill. Parent class implements the interface and Child class is forced to implement the same; what the hell obligation is this?
There is something that is at rescue. If you modify the MyList generic class as :
public class MyList<T extends Comparable<? super T>> {
�
�
}
Now it is ok! What does that mean? It means still parameterized type must be be class that implements Comparable interface as T extends Comparable says but it that unknown class�s (represented by wildcard �?�) superclass implements the Comparable , that will also do, that is what we wanted to have in our Person-Driver relationship.
Now this is allowed:
MyList<Driver> mylist2 = new MyList<Driver>();//Now it is ok!
Little more talk is left:
public class MyList<T extends Comparable> {
}
This generic class definition is less restrictive than
public class MyList<T extends Comparable<T>> {
}
The first one says, that all the elements all allowed if at least the parent class implements the Comparable interface.
The second one restricts you to by saying this; all the elements must be comparable or each element added to the Mylist must be object of the class that implements the Comparable interface.
You make the second definition flexible by doing that:
public class MyList<T extends Comparable<? super T>> {
}
It means, if the super class of the added element implements the Comparable interface, it will do.
I see following two class definitions conveying the same meaning! Don�t you?
public class MyList<T extends Comparable>{}
and
public class MyList<T extends Comparable<? super T>>{}
I hope this explanation helps you!
