Java 如何使用泛型并从父类继承而不引起名称冲突？

我在Java中有一个名为

Flight

的父类。我有子类：

JetFlight

，

NormalFlight

，等等，它们继承自

Flight

我希望所有子类都从

Comparable

接口实现

compareTo

。我希望它们继承自

Flight

，因为我希望使用多态性（例如，启动

Flight

数组，并用

JetFlight

、

NormalFlight

等对象填充它）

这是我的父类代码：

public abstract class Flight  {
    public abstract int compareTo(Object o);
}

这是其中一个儿童班的代码：

public class JetFlight extends Flight implements Comparable<JetFlight> {
    private int flightTime;
    public JetFlight(int flightTime) {
        this.flightTime = flightTime;
    }
    public int compareTo(JetFlight j) {
        return this.flightTime - j.flightTime;
    }
}

public class JetFlight扩展了飞行工具{
私人飞机飞行时间；
公共喷气式飞机（国际飞行时间）{
this.flightTime=flightTime；
}
公共内部比较（JetFlight j）{
返回this.flightTime-j.flightTime；
}
}

由于以下两个错误，此代码无法编译：

1）

java.lang.Comparable中的compareTo（T）与Flight中的compareTo（Object）冲突；两个对象具有相同的擦除，但都不覆盖另一个对象。

2）

类“JetFlight”必须声明为抽象，或在“Flight”中实现抽象方法“compareTo（Object）”

---

当我想从一个类继承，同时在子类上使用泛型时，我该如何处理这种情况？

如果使用泛型，您将摆脱这个问题

你需要定义

public abstract int compareTo(JetFlight o);

并且还使用

public class JetFlight extends Flight implements Comparable<? extends JetFlight>

---

public class JetFlight扩展了飞行实现可比性选项1：因为您的比较是基于飞行时间的，据我所知，变量
flightTime
可以在父类中向上推送，因为所有航班都将具有此功能。然后在父类本身中实现compareTo（）方法

选项2：如果您希望保持当前代码的状态：

    public abstract class Flight implements Comparable<Flight> {
    public abstract int compareTo(Flight o);
}

您可以在
T
类型上参数化
compariable
，该类型由
航班
限定：

abstract class Flight<T extends Flight<T>> implements Comparable<T>  {
    public abstract int compareTo(T o);
}

class JetFlight extends Flight<JetFlight> {
    private int flightTime;
    public JetFlight(int flightTime) {
        this.flightTime = flightTime;
    }

    public int compareTo(JetFlight j) {
        return this.flightTime - j.flightTime;
    }
}

抽象类航班{
公开摘要与比较（TO）；
}
喷气式飞机延长了飞行时间{
私人飞机飞行时间；
公共喷气式飞机（国际飞行时间）{
this.flightTime=flightTime；
}
公共内部比较（JetFlight j）{
返回this.flightTime-j.flightTime；
}
}
你不能。如果航班实现了Comparable（为什么它没有，为什么它有一个compareTo（Object）方法呢？），那么每个航班都必须与任何其他航班具有可比性，无论其实际类型是什么。如果一架喷气机只能与一架喷气式飞机相媲美，那么在基类中就不应该有一种比较的方法：无论如何，你不能将两个航班进行比较，因为子类不支持它。你可能要考虑为特定的子类定义<代码>比较器< /代码> s，如果
Flight
的每个子类只能与同一子类的其他对象进行比较，那么您不能对混合
Flight[]
数组进行排序。在这种情况下，您的
compareTo
应该抛出
ClassCastException
<代码>未声明IllegalArgumentException

。这就是说，这样一个

与

实现的比较一开始可能是不合适的。（见JB在问题下的评论。）@Radiodef同意例外情况。但是，对于compareTo方法，如果OP坚持按照前面描述的方式创建类，还有其他选择吗？谢天谢地，这不是编译。

abstract class Flight<T extends Flight<T>> implements Comparable<T>  {
    public abstract int compareTo(T o);
}

class JetFlight extends Flight<JetFlight> {
    private int flightTime;
    public JetFlight(int flightTime) {
        this.flightTime = flightTime;
    }

    public int compareTo(JetFlight j) {
        return this.flightTime - j.flightTime;
    }
}