Interfaces and Comparable

After this lesson, you will be able to:

• Explain what an interface is and why Java uses them
• Declare an interface and implement it in a class
• Implement Comparable<T> to define natural ordering for custom objects
• Write a correct compareTo method that returns negative, zero, or positive
• Sort arrays of objects using Arrays.sort with Comparable
• Explain the relationship between compareTo and equals

The Sorting Problem

You already know how to sort arrays of primitives:

int[] nums = {5, 2, 8, 1, 9};
Arrays.sort(nums);  // Works: [1, 2, 5, 8, 9]

String[] words = {"zebra", "apple", "banana"};
Arrays.sort(words);  // Works: [apple, banana, zebra]

Now try sorting an array of Student objects:

Student[] roster = {
    new Student("Alice", 3.8, 1001),
    new Student("Bob", 3.2, 1002),
    new Student("Charlie", 3.5, 1003)
};

Arrays.sort(roster);  // ClassCastException! Java doesn't know how to compare Students.

Java does not know how to compare Students. Should Alice come before Bob because her name is alphabetically earlier? Because her GPA is higher? Because her ID is lower? That is a design decision that only you can make. You need a way to tell Java the natural ordering for Student objects.

From CSCD 110: In Python, you could sort objects with a key function: sorted(roster, key=lambda s: s.gpa). Java takes a different approach. Instead of passing a key function from the outside, you make the class itself declare how its objects should be compared. The class implements a contract called Comparable.

Interfaces: A Contract

An interface is a Java construct that specifies a contract: “If you claim to implement this interface, you promise to provide these methods.” It declares what methods must exist, but says nothing about how they work. That is the job of the class that implements the interface.

The syntax for declaring an interface:

public interface Greetable {
    String greet();
    // Method signature only — no body, no curly braces with code
}

A class that implements the interface must provide every method the interface declares:

public class Student implements Greetable {

    private final String name;
    // ... other fields, constructor ...

    @Override
    public String greet() {
        return "Hi, I'm " + name;
    }
}

The implements keyword is the promise. The @Override annotation tells the compiler: “Verify that this method actually fulfills an interface requirement.” If you misspell the method name or get the return type wrong, the compiler catches it immediately.

Key Insight: Interfaces separate what a class must do from how it does it. The interface defines the contract; the class fulfills the promise. This is the foundation of polymorphism — code that works with the interface works with any class that implements it.

The Comparable Interface

Java provides a built-in interface called Comparable<T>. Here is the entire interface:

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

One method. That is the whole contract. If a class implements Comparable<T>, it promises to provide a compareTo method that defines how objects of that class should be ordered.

The <T> is a type parameter — it gets replaced by the actual class name when you implement it. For Student, you write Comparable<Student>, so compareTo takes a Student parameter instead of a generic Object.

The compareTo Contract

The compareTo method returns an int with the following meaning:

Think of it as subtraction on a number line. If this is “smaller” (should come first), the result is negative. If they are the same, the result is zero. If this is “larger” (should come later), the result is positive.