public <T extends SomeBaseClass> void myMethod(Class<T> clz)

public void myMethod(Class<? extends SomeBaseClass> clz)

List<String> jedis = new ArrayList<String>();
jedis.add("Obiwan");

List<? extends CharSequence> ls = jedis
CharSequence obiwan = ls.get(0); //Ok
ls.add(new StringBuffer("Anakin")); //Not Ok

List<Object> jedis = new ArrayList<Object>();
jedis.add("Obiwan");

List<? super String> ls = jedis;
ls.add("Anakin"); //Ok
String obiwan = ls.get(0); //Not Ok, we can´t be sure list is of Strings.

public static void sort(List<? extends Number> numbers){
    Object[] a = numbers.toArray();
    Arrays.sort(a);
    ListIterator<? extends Number> i = numbers.listIterator();
    for (int j=0; j<a.length; j++) {
        i.next();
        i.set((Number)a[j]); //Not Ok, you cannot be sure the list is of Number
    }
}

public static <T extends Number> void sort(List<T> numbers){
    Object[] a = numbers.toArray();
    Arrays.sort(a);
    ListIterator<T> i = numbers.listIterator();
    for (int j=0; j<a.length; j++) {
        i.next();
        i.set((T)a[j]);
    }
}

List<? extends Number> ints = new ArrayList<Integer>();
List<? extends Number> floats = new ArrayList<Float>();
sort(ints);
sort(floats);

class Foo {
    public <T extends SomeBaseClass> void myMethod(Class<T> clz) { }
}

class Bar extends Foo {
    public void myMethod(Class<? extends SomeBaseClass> clz) { }
}

<T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

Comparable<?> max(Comparable<?> a, Comparable<?> b) {
    return a.compareTo(b) > 0 ? a : b;
}

max(Integer.MAX_VALUE, "hello");

<T extends Comparable<T>> T max(T... ts) {
    if (ts.length == 0) {
        return null;
    }
    T max = ts[0];
    for (int i = 1; i < ts.length; i++) {
        if (max.compareTo(ts[i]) > 0) {
            max = ts[i];
        }
    }
    return max;
}

public static void reverse(List<?> list) { rev(list);}
private static <T> void rev(List<T> list){ ... }