Generic Method with Lower Bound

Java-Generic Method with Lower Bound

Generic Method with Lower Bound

Lower bounds are useful for cases where we want to be sure that a particular container instantiation can hold a particular element type, without limiting it to just the specific type of the element. For example, consider the following generic method:

Note that T extends Comparable<T>. The Comparable is an generic interface declared in java.lang. This interface declares the compareTo( ) method that is used to determine what Java calls the natural ordering of instances of a class. A class that implements Comparable defines objects that can be ordered. The Comparable interface declared as follows:

The type variable indicates the type of the other parameter.  For example, the String class implements Comparable<String>, and its compareTo method is declared as compareTo(String other)Comparable is a generic type so we could have define it as <T extends Comparable<T>. This type declaration ensures that test( ) method take an object of type T that are implements Comparable<T> only. It would work fine for many classes. For example, T is the type String, and String is a subtype of Comparable<String>, or T is the type Integer, and Integer is a subtype of Comparable<Integer> :

Generic Method with Lower Bound

But we run into a problem of some situation. Consider the following classes and the call of test( ) method :

The test( ) method cannot be take the type of Data2. Because Data2 extends Data1 and implements Comparable<Data1>. Thus, Data2 implements Comparable<Data1> but not Comparable<Data2>. In a situation such as this one, supertypes come to the rescue :

This is a wildcard instantiation of the Comparable interface. This wildcard instantiation ensures that test( ) method take an object of type T that are implements Comparable<T> or Comparable<supertype of T upto Object>. Thus, the test( ) method take an object of Data2. Besacuse Data2 implements Comparable<Data1>, Data1 is a supertype of Data2.

Program



Program Source

class Data1 { }

class Data2 extends Data1 implements Comparable {

    public int compareTo(Data1 d) {

        return 10;
    }
}

public class Javaapp {
    
    static <T extends Comparable<? super T>> void test(T t) { }

    public static void main(String[] args) {
        
        test(new Integer(50));
        test(new Data2());
    }
}

Leave a Comment