如何在这里完成compareTo（Object o）方法？

Question

This is the abstract class:

public abstract class AbstractRecord {
    /**
     * Simple getter for the similarity 
     * 
     * @return <code>int</code> containing the similarity
     */
    public abstract int getSimilarity();

    /**
     * Simple getter for the title <code>String</code>
     * 
     * @return <code>String</code> containing the title
     */
    public abstract String getTitle();

    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "["+this.title+":"+this.similarity+ "]";
    }
}

and this is the extended class from it:

public class Record extends AbstractRecord implements Comparable<Record>{
    private int similarity;
    private String title;

    public Record(String title, int similarity) throws IndexException {
        if (title == null || title.isEmpty() || similarity < 0) {
            throw new IndexException("Missing title");
        }
        this.similarity = similarity;
        this.title = title;
    }


    @Override
    public int compareTo(Record r) {
        int result;
        result = r.compareTo( //what should I put here? );
        return result;
    }

    @Override
    public int getSimilarity() {
        return similarity;
    }

    @Override
    public String getTitle() {
        return title;
    }

}

Just fixed super variable problem and here's a new problem.. How can I fixed the compareTo() method here, trying to compare the input Record r with the local one. Thank you!

Answer 1

 private int similarity;
 private String title;

No need to declare title and similarity in subclass you can initialize it using super keyword

Answer 2

Your title and similarity members of the Record class hide the members of the same name of AbstractRecord .

If all AbstractRecord s have a title and similarity , it would make more sense to implement getTitle() and getSimilarity() in AbstractRecord , instead of in Record .

Answer 3

Make your fields of abstract class protected or public . And for security and access permission's sake, protected is suggested.

Answer 4

your variables are automatically inherited. There is no need to declare it in the subclass. It is not going to override the superclass variable

public class Record extends AbstractRecord implements Comparable<Record>{
    //your methods here
}

Above code should suffice

Answer 5

Both the fields of base class will be inherited to child class. You simply need to use super keyword to access fields of Base class as:

super.similarity and super.title

Answer 6

first of all you have to initialize the parent class( AbstractRecord ) variable it can by done in parent class constructor or in child class by super keyword

super.title = "value";

This same keyword you can use to access it too.

public String getParentTitle(){
     return super.title;
}

Answer 7

You should not redefined the title and similarity attributes in the subclass, and making abstract getters in the class where the actual attributes are defined seems over-complicated. Then as a rule of thumb, attributes in a class should be initialise in the class.

Sub-classes inherits all public and protected members (methods and attributes). It means you can use them without having to redeclare it.

In the below simplified version of your code, I kept parameter checking in the subclass constructor, assuming you can have different subclasses with different constraints. Note that if the comparison of records is only on title and similarity , you can implement it in AbstractRecord .

public abstract class AbstractRecord {
    protected String title;
    protected int similarity;

    protected AbstractRecord(String title, int similarity) {
        this.title = title;
        this.similarity = similarity;
    }

    public  int getSimilarity() {return similarity;}

    public  String getTitle() {return title;}

    public String toString() {
        return "["+this.title+":"+this.similarity+ "]";
    }

    // some abstract methods
}

public class Record extends AbstractRecord implements Comparable<Record>{

    public Record(String title, int similarity) throws IndexException {
        super(title, similarity);
        if (title == null || title.isEmpty() || similarity < 0) {
            throw new IndexException("Missing title");
        }
    }

    @Override
    public int compareTo(Record r) {
        return 0;
    }
    // implementation of abstract methods from AbstractRecord 
}