Java Generics method structure explanation

It simply means the generic type T must extend Comparable<T>. By telling the compiler that, your T objects will have all the public methods of Comparable<T> available to it.

Comparable<T> is an interface whose contract means "we can compare this object to one of type T". If the object itself is of that type T, then the object is comparable to itself. This is the behavior that we desire here. Examples of similar behavior are Integer which implements Comparable<Integer>.

Here, this method requires that you pass in objects that are comparable to themselves.

If those objects are of type T then they must implement Comparable<T> in order to be comparable with each other. Since generic extends/implements constraints use the keyword extends in all cases, the generic declaration is T extends Comparable<T>.

It restricts that T must be a class which implements Comparable, so that an instanceof T can compare to another instance of T

To be able to access: compareTo(T o); we must extend the Comparable interface.

Why, because only when we do that can we access it, as it isn't available beforehand.

Wikipedia has an excellent article on Generics in Java.

The method takes an array of items and a single item, and I guess from the name that it will return the number of items in anArray that are "greater than" elem.

This will work for any type T that has a well-defined "greater than" relation, i.e. any type that is Comparable to itself, which is precisely what <T extends Comparable<T>> expresses - any type T so long as that type is an implementation of Comparable with the target type itself as its type parameter.

countGreaterThan method is a generic method that requires to compare an object with another object of its type. A compareTo ( of the Comparable interface ) method provides the types implementing Comparable interface with a way to compare two objects of that type.

Since countGreaterThan method makes use of the compareTo method, it is required that the arguments supplied to the method are of those types that implement the Comparable interface.

When you declare a bounded type parameter, you're telling the compiler that T is a type that implements the Comparable interface. Hence it is safe to invoke the compareTo method on the objects of type T. So declaring the bounded type as > lets you invoke the compareTo method on the object of the type T. Now the compiler will let you invoke the compareTo method on the objects of the generic type. Not only that, the compiler will also enforce that the type of the arguments supplied to the method countGreaterThan implement the Comparable interface.

T means any type. So if you have the method

public static int countGreaterThan(T[] anArray, T elem)

that means you can put call it like this:

public static int countGreaterThan(String[] anArray, String elem)

or with any other class. The only constraint you have here is that both classes represented by T are the same.

The > means, that T needs to be a subclass of Comparable. So T needs to implement Comparable. An example would be Integer, which implements Comparable. That means, Integer has the method Integer.compareTo(Integer i).

The > constraint might be usefull if you want to use certain methods that are defined by that interface. For your method countGreaterThan(): this one needs to use .compareTo() to figure out if an input-object is greater than the other one, so every input-object needs to have the .compareTo()-method. So you declare > and now you can use .compareTo().

Since this is a static function, information about T has to accompany it. For instance methods, T will already be defined/constrained. I.e.:

class Example<T extends Comparable<T>> {
    public void doSomethingWithT(T param) { ... };
}