Question

这是抽象类：

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+ "]";
    }
}

这是它的扩展类：

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;
    }

}

修复超级变量问题，这是一个新问题.. 如何在此处修复compareTo（）方法，尝试将输入Record r与本地记录进行比较。谢谢！

Answer 1

 private int similarity;
 private String title;

无需在子类中声明标题和相似性，您可以使用超级关键字

对其进行初始化

Answer 2

您的记录类的title和similarity成员会隐藏AbstractRecord同名的成员。

如果所有AbstractRecord都有title和similarity，那么在getTitle()中实施getSimilarity()和AbstractRecord会更有意义，而不是Record。

Answer 3

制作抽象类protected或public的字段。出于安全性和访问权限的考虑，建议使用protected。

Answer 4

您的变量会自动继承。没有必要在子类中声明它。它不会覆盖超类变量

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

上面的代码应该足够了

Answer 5

基类的两个字段都将继承到子类。您只需使用super关键字来访问Base类的字段：

super.similarity和super.title

Answer 6

首先，您必须初始化父类（ AbstractRecord ）变量它可以通过超级关键字

在父类构造函数或子类中完成

super.title = "value";

您也可以使用相同的关键字来访问它。

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

Answer 7

您不应该重新定义子类中的title和similarity属性，并且在定义实际属性的类中创建abstract getter似乎过于复杂。然后根据经验，类中的属性应该在类中初始化。

子类继承所有public和protected成员（方法和属性）。这意味着您可以使用它们而无需重新声明它。

在下面简化的代码版本中，我在子类构造函数中保留了参数检查，假设您可以使用不同的子类和不同的约束。请注意，如果记录的比较仅在title和similarity上，则可以在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 
}

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

7 个答案: