Question

I have an abstract class Person and and interface comparable, which is also used for some other part of the program. Currently I have a method compareTo() in Person. When I try to compile, I get :

The type Student must implement the inherited abstract method 
 Comparable<Person>.compareTo(Person, Person)

What exactly do I have to do? I don’t wont to implement this method in any of the subclasses, because I need this method for all of them, Student, Tutor, Professor, etc… Is there a better way of doing this?

Interface:

interface Comparable<Element> {
    public int compareTo(Element nodeA, Element nodeB);
}

Abstract class Person:

abstract class Person implements Comparable<Person> {

    protected String name;

    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String newName) {
        name = newName;
    }
    public String toString() {
        return name;
    }

    public int compareTo(Person personB) {
        int comp = this.name.compareTo(personB.getName());
        return comp;
    }
}

And class Student

class Student extends Person implements Comparable<Person> {

    private int id;

    public Student(String name, int id) {
        super(name);
        this.id = id;
    }

    public int getID() {
        return id;
    }

    public void setID(int newID) {
        id = newID;
    }

    public String toString() {
        return id + ", " + name;
    }
}

Answer 1

Change your interface from:

interface Comparable<Element> 
{     
   public int compareTo(Element nodeA, Element nodeB); 
}

to:

interface Comparable<Element> 
{     
   public int compareTo(Element nodeA); 
}

And make your Person class be defined as:

abstract class Person implements Comparable<? extends Person> { /* ... */ }

And make your Student (and other Person-subclasses be):

class Student extends Person { /* ... */ }

That is all.