Interfaces are used frequently in the Java run-time library. Here is the source of interface Comparable in the java.lang package up to JDK 1.4. (We'll show the JDK 1.5 code, which is different, soon).

All classes that implement Comparable have to provide a compareTo() method. It allows two objects of the same class to be put in order with respect to one another, that is, they can be compared.

If you read the API documentation, you will see that implementations of compareTo() must return a negative, zero, or positive int, depending on whether “this” is smaller, equal to, or greater than the object parameter. There isn't any way for the compiler to enforce this level of meaning, and if you make compareTo() do anything different for one of your classes, this code will be broken anywhere you use that class in place of a Comparable.

Here's a complete example that implements the Comparable interface. To keep it simple, the example is a class that “wraps” an int as an object.

You can declare MyInts and compare them like this:

That's the way Comparable looked before JDK 1.5. In JDK 1.5, classes and interfaces are allowed to take generic parameters, and Comparable was changed for that.

Generic types in JDK 1.5: A preview

JDK 1.5 introduced the generic feature, allowing you to use types as parameters, just as you can use variables as parameters. The java.lang.Comparable interface was upgraded. You have the choice of compiling for the new syntax or the old syntax. The old syntax is shown in this chapter and the new syntax is explained in the chapter on generics. To give you an appetizer, here's what the new feature looks like:

• Comparable now takes a generic type parameter, which looks like a name in angle brackets. It is read as “Comparable of T”. The name is used inside the interface to specify that the argument to compareTo must be of this yet-to-be-specified type:

  public interface Comparable <T> {
     public int compareTo(T t);
  }

• Any class that implements Comparable must provide an actual type argument, to be used in place of the generic type parameter. This gives the type of the thing to which you are comparing. You usually compare two objects of the same type, so it will usually be a repetition of the class name (here MyInt):

  class MyInt implements Comparable <MyInt> { int mi; /* code */

• The compareTo() method now uses an argument of the type you are comparing to, not of type Object, so no casting is necessary. The main benefit is that the compiler will not let you compare a MyInt with an object of some other class.

  public int compareTo(MyInt other) {
     return (this.mi - other.mi);  // NEW - no cast from Obj
  }

• If you add these four lines to MyInt, you have a complete compilable example:

    private int mi;    // stores the int value
    public MyInt(int i) { mi = i; }       // constructor
    public int getMyInt() { return mi; }  // getter
  }

• If you add a main method with these lines, you can run the example. These lines are the same whether you use the old style or you use the new generic feature.

  MyInt m4 = new MyInt(4);
  MyInt m5 = new MyInt(5);
  
  int result = m4.compareTo(m5);
  if (result<0) System.out.println("m4 < m5");

There is no change in the use of Comparable classes. The only changes for generics in this example are in the definition of Comparable and the definition of classes that implement the Comparable interface.