Gnerics Doubt.

[Sumukh Deshpande]

I am reading a tutorial on Generics. I have come across a doubt.
Here is the tutorial

For convenience I am pasting the code.
In tutorial type erasure phenomena in Generics is explained.
So the code below is before Type Erasure:

  interface Comparable <A> {
      public int compareTo( A that);
    }
    final class NumericValue implements Comparable <NumericValue> {
      priva te byte value; 
      public  NumericValue (byte value) { this.value = value; } 
      public  byte getValue() { return value; } 
      public  int compareTo( NumericValue t hat) { return this.value - that.value; }
    }
    class Collections { 
      public static <A extends Comparable<A>>A max(Collection <A> xs) {
        Iterator <A> xi = xs.iterator();
        A w = xi.next();
        while (xi.hasNext()) {
          A x = xi.next();
          if (w.compareTo(x) < 0) w = x;
        }
        return w;
      }
    }
    final class Test {
      public static void main (String[ ] args) {
        LinkedList <NumericValue> numberList = new LinkedList <NumericValue> ();
        numberList .add(new NumericValue((byte)0)); 
        numberList .add(new NumericValue((byte)1)); 
        NumericValue y = Collections.max( numberList ); 
      }
    }   

After Type Erasure it becomes:

  interface Comparable {
  public int compareTo( Object that);
}
final class NumericValue implements Comparable {
  private byte value; 
  public  NumericValue (byte value) { this.value = value; } 
  public  byte getValue() { return value; } 
  public  int compareTo( NumericValue t hat)   { return this.value - that.value; }
  public  int compareTo(Object that) { return this.compareTo((NumericValue)that);  }
}
class Collections { 
  public static Comparable max(Collection xs) {
    Iterator xi = xs.iterator();
    Comparable w = (Comparable) xi.next();
    while (xi.hasNext()) {
      Comparable x = (Comparable) xi.next();
      if (w.compareTo(x) < 0) w = x;
    }
    return w;
  }
}
final class Test {
  public static void main (String[ ] args) {
    LinkedList numberList = new LinkedList();
    numberList .add(new NumericValue((byte)0)); 
    numberList .add(new NumericValue((byte)1)); 
    NumericValue y = (NumericValue) Collections.max( numberList ); 
  }
}  

Now my doubts are:

1. What does this mean

<A extends Comparable<A>A 

in <br />

  public static <A extends Comparable<A>A max(Collection ><A> xs)   

2. Also in tutorial it is said that Type Erasure it is said that:

When the compiler finds the definition of a generic type or method, it removes all occurrences of the type parameters and replaces them by their leftmost bound, or type Object if no bound had been specified.

What does it mean here by leftmost bound?

Please help me to clear the doubt.
Thanks in advance.

[Campbell Ritchie]

There are other tutorials, eg the Java™ Tutorials, which has two sections about generics in. You might find that easier to understand. But Angelika Langer is usually very good.

There is a problem that in some instances < appears as ><; I have tried to correct that in your post.

What <T extends Comparable<T>> means is that you have to have a particular type "T", and that type has to implement the Comparable interface. And that Comparable interface has to compare to the same type "T". Actually, I think the usual style is <T extends Comparable<? super T>> which means that the Comparable methods must take a "T" or any of its superclasses as its type.
I think the bit about "leftmost bound" means that the types are changed to the type which is highest (ie nearest to java.lang.Object) in its inheritance tree.

Note you write extends in generics, not implements.

[Sumukh Deshpande]

Thanks Campbell Ritchie.

Your explanation has cleared my doubts.

[Campbell Ritchie]

You're welcome