public static <T extends Comparable<? super T>> void sort(List<T> list)

This declaration says, that argument to sort() method must be of a type List<T>, 
where T could be any type that implements Comparable<? super T> (sort requires compareTo method defined in Comparable to compare elements of list)
Comparable<? super T> means that type ? passed to Comparable could be T or any supertype of T. 

Consider this code: 

class A implements Comparable<A>{

	private int i = 0; 
	A(int x){
		i = x;
	}
	
	@Override
	public int compareTo(A o) {
		return i - o.i;
	}
	
	public String toString(){
		return ""+i;
	}
	
}

class B extends A{
	B(int x){
		super(x + 10);
	}
	//we don't override compareTo
}

public class Test {
	
	public static void main(String[] args){
		List<B> list = new ArrayList<B>();
		list.add(new B(3));
		list.add(new B(1));
		list.add(new B(4));
		list.add(new B(2));
		Collections.sort(list);//public static <T extends Comparable<? super T>> void sort(List<T> list)1
		for(B x : list){
			System.out.println(x);
		}
	}
}

 

 

Class B doesn't implement Comparable<B> (and doesn't define it's own compareTo(B b) method). 
Class B inherits compareTo(A x) method from class B (we can say that it implements Comparamble<A>). 
And sort(List<B>) compiles fine, it is conforming with declaration: public static <B extends Comparable<? super B>> void sort(List<B> list)