不能与父子孙继承进行比较

Question

给出以下代码：

public abstract class Participant {
    private String fullName;

    public Participant(String newFullName) {
        this.fullName = new String(newFullName);
    }

    // some more code 
}


public class Player extends Participant implements Comparable <Player> {    
    private int scoredGoals;

    public Player(String newFullName, int scored) {
        super(newFullName);
        this.scoredGoals = scored;
    }

    public int compareTo (Player otherPlayer) {
        Integer _scoredGoals = new Integer(this.scoredGoals);
        return _scoredGoals.compareTo(otherPlayer.getPlayerGoals());
    }

    // more irrelevant code 
}

public class Goalkeeper extends Player implements Comparable <Goalkeeper> { 
    private int missedGoals;        

    public Goalkeeper(String newFullName) {
        super(newFullName,0);
        missedGoals = 0;
    }

    public int compareTo (Goalkeeper otherGoalkeeper) {
        Integer _missedGoals = new Integer(this.missedGoals);
        return _missedGoals.compareTo(otherGoalkeeper.getMissedGoals());
    }

    // more code 
}

问题是 Goalkeeper 不会遵守。

当我尝试编译该代码时，Eclipse 会抛出：

The interface Comparable cannot be implemented more than once with 
different arguments: Comparable<Player> and Comparable<Goalkeeper>

我不想与 Player 进行比较，而是与 Goalkeeper 进行比较，并且仅与他进行比较。

我做错了什么？

Answer 1

Angelika Langer 的 泛型常见问题解答 #401 中描述了该问题：

一个类可以实现同一个泛型的不同实例化吗
接口？

不，类型不得直接或间接派生自
同一通用接口的两个不同实例。

原因
此限制是通过类型擦除进行翻译。键入后
删除同一通用接口的不同实例
折叠为相同的原始类型。运行时没有区别
不同实例之间不再存在。

（我强烈建议您查看问题的完整描述：它比我引用的内容更有趣。）

为了解决此限制，您可以尝试以下操作：

public class Player<E extends Player> extends Participant implements Comparable<E> {
    // ...
    public int compareTo(E otherPlayer) {
        Integer _scoredGoals = this.scoredGoals;
        return _scoredGoals.compareTo(otherPlayer.getPlayerGoals());
    }
    // ...
}


public class Goalkeeper extends Player<Goalkeeper> {
    // ...
    @Override
    public int compareTo(Goalkeeper otherGoalkeeper) {
        Integer _missedGoals = this.missedGoals;
        return _missedGoals.compareTo(otherGoalkeeper.getMissedGoals());
    }
    // ...
}

Answer 2

就您的设计逻辑而言，您没有做错任何事情。然而，Java 有一个限制，阻止您实现具有不同类型参数的相同泛型接口，这是由于它实现泛型的方式（通过类型擦除）造成的。

在您的代码中，Goalkeeper 继承自 Player 它的 Comparable 实现，并尝试添加一个 Comparable; 自己的；这是不允许的。

解决此限制的最简单方法是覆盖 Goalkeeper 中的 Comparable，将传入的玩家投射到 Goalkeeper，然后进行比较传给这个守门员。

编辑

public int compareTo (Player otherPlayer) {
    Goalkeeper otherGoalkeeper = (Goalkeeper)otherPlayer;
    Integer _missedGoals = new Integer(this.missedGoals);
    return _missedGoals.compareTo(otherGoalkeeper.getMissedGoals());
}

Answer 3

我想在现有的好的答案的基础上补充两点。

1. 即使您尝试过的设计是可行的，您也可能不想要它，这是有原因的。它有点蓬松。
2. 除了谢尔盖·卡利尼琴科提出的解决方案之外，还有其他可能的解决方案。

您的设计有缺点

如您所知，您的设计不可能用 Java 实现。这是 Java 泛型的限制。让我们暂时设想一下如果可能的话。我认为这意味着许多人会感到惊讶和/或困惑的一些行为。

根据您的设计，假设我们有：

    Goalkeeper goalkeeper1 = new Goalkeeper("Imene");
    Goalkeeper goalkeeper2 = new Goalkeeper("Sofia");
    Player goalkeeper3 = new Goalkeeper("Maryam");

    goalkeeper1.compareTo(goalkeeper2); // would call Goalkeeper.compareTo(Goalkeeper)
    goalkeeper1.compareTo(goalkeeper3); // would call Player.compareTo(Player)

我们可以更进一步：

    List<? extends Player> list1 = new ArrayList<Goalkeeper>();
    List<? extends Player> list2 = new ArrayList<Player>();

现在我们（仅）用守门员填充两个列表并对它们进行排序。现在，list1 应该使用 Goalkeeper.compsreTo() 进行排序，list2 可能使用 Player.compareTo() 进行排序。开始变得混乱了，不是吗？这样的设计你想要吗？您是否更喜欢一种更明确何时使用哪种比较方式的方法？ （是的，我知道，您无法通过变量 list1 和 list2 填充列表。您必须先填充列表，然后再将它们分配给这两个变量。

）解决方案

解决方案 1：使用 Comparator 代替其中一个 compareTo 方法（或两者）。 Comparator 或 Comparator 或两者之一。例如：

    Comparator<Player> playerComparator = Comparator.comparingInt(Player::getScoredGoals);

解决方案 2：为非守门员的球员引入一个单独的类。由于没有更好的词，我暂时将其称为 FieldPlayer。 FieldPlayer 和 Goalkeeper 都应该是 Player 的子类。 FieldPlayer 实现了 Comparable，并且 Goalkeeper 已经实现了 Comparable。现在Player不需要实现Comparable，并且避免了冲突。