Java 泛型和继承（具体问题）

Question

我想继承泛型类和接口。有一个问题我无法理解。问题体现在下面的简化代码中：

public interface A1 <T extends F1<?>> {
    public void compare(T f1, T f2);
}

public class F1 < T extends A1<? extends F1<T>> >
{
    T a;
    public void compare(F1<T> f) {
        a.compare(this, f);
    }
}

A1 在A1.java，F1 在F1.java。

我得到编译时错误：

The method compare(capture#1-of ? extends F1<T>, capture#1-of ? extends F1<T>) 
in the type A1<capture#1-of ? extends F1<T>> is not applicable for the 
arguments (F1<T>, F1<T>)

我需要 A1 < ? extends F1< T>> 用于继承 F1 的类。

附加信息（编辑后）：

我想要 2 个层次结构（“O”而不是“F”，“C”而不是“A”）：

• 类的第一个层次结构（O1、O2 ...）包含对象的所有相关信息以及“比较器”（分析一对相同类型的两个对象的任何函数）。对象的类定义了它接受的比较器的类型，主要要求是比较器应该接受托管对象类型的 2 个对象。例如，O1 只能接受所有比较 O1 的比较器，O2 可以有接受 O2 的比较器。
• 类的第二个层次是比较器（C1、C2...）本身。他们比较层次结构 1 中的对象。

两个层次结构中的每个元素都添加了在子类中使用的补充功能。

让我们考虑以下用例，这是通过这些层次结构的路径之一：

• O1 有 2 个成员（不是类型！）：val（任何类型），cmp（类型为 C1，只接受 O1）。
• C1_1 没有对应的对象O，但它实现了与集合相关的附加功能。它可以比较集合中的对象（“基本”类型，如int、String、TColor 和“复杂”对象O）并应用仅返回 1 个值（例如最大值）的聚合器。 如果集合是基本类型，则使用cmp2 来比较集合中的元素。对于集合中的复杂对象，使用它们的集成比较器。
• C1_1_1 实现了如何比较对象列表 (1:1)。 C1_1_2（未显示）可用于比较对象集，例如与叉积。
• O1_1 具有 TVALB 类型的 val，其中 extend List<TVALA> 和比较器 C1_1_1。

C1_1_1/2 的其他子类可以有更精细的实现来比较基本对象和复杂对象。

支持代码：

public abstract class O1 <TVAL, TC extends C1<? extends O1<TVAL>>>
{
    TVAL val;
    TC cmp;
    public double compare(O1<TVAL, TC> o) {
        return cmp.compare(this, o);
    }
}
public interface C1 <TO extends O1<?, ?> > {
    public double compare(TO t1, TO t2) {
      // ...
    }
}

public abstract class C1_1 <
        TVALA,
        TVALB extends Collection<TVALA>,
        TO extends O1<TVALB, ?>
    >
    extends C1 <TO> {

    Cmp2<TVALA, Double> cmp2;
    IAggregator<TVALA> aggr;

    Double compare(TO o1, TO o2) {
        return aggr.apply(
            compPairs(o1.val, o2.val, cmp2)
        );
    }

    abstract pairs<TVALA> compPairs(
        TVALB b1
        , TVALB b2
        , Cmp2<TVALA> cmp2);

    // aggregation
    public static class Aggr1<TVALA> implements IAggregator<TVALA> {
        public Double apply(pairs<TVALA> pairs) {
            //...
        }
    }
    public static class Aggr2<TVALA> implements IAggregator<TVALA> {
        // ...
    }
}

public abstract class C1_1_1 <
        TVALA,
        TVALB extends List<TVALA>,
        TO extends O1<TVALB, ?>
    >
    extends C1_1 <TO> {
    pairs<TVALA> compPairs(
            TVALB b1
            , TVALB b2
            , Cmp2<TVALA> cmp2) {
        // ...
    }
}

public abstract class O1_1 <
    TVALA extends O1<?,?>,
    TVALB extends List<TVALA>
    , TC extends C1_1_1<TVALA, TVALB, ? extends O1_1<TVALA, TVALB, TC>>>
    extends O1<TVAL>
{
    // ...
}

我使用依赖注入在特定类中分配比较器（C-tree 到对象O）。因此，这种方法（如果可行的话）可以灵活地为特定类型的对象选择合适的比较器。

Answer 1

您可以删除您的A1 类，只使用Comparable 接口。

public class F1<T extends Comparable<T>> implements Comparable<F1<T>> {
    T t;

    @Override public int compareTo(F1<T> other){
        return t.compareTo(other.t);
    }
}

Answer 2

让我们先重命名类型变量，因为两个 T 代表不同的东西，希望它能让事情更清楚：

public interface A1 <T extends F1<?>> {
    public void compare(T t1, T t2);
}

public class F1 < S extends A1<T extends F1<S>> >
{
    S s;
    public void compare(F1<S> f) {
        s.compare(this, f);
    }
}

现在您看到您实际上是在s 上调用compare，它是A1<T> 的一个实例，其中T 可以是F1<S> 的子类。但是，您传递的参数的类型为F1<S>，而不是子类T，这几乎就是编译器所说的。

本质上，您使方法参数是协变的，而它们可能应该是逆变的。为此，请使用super 而不是extends：

public class F1 < S extends A1<? super F1<S>> >
{
    S s;
    public void compare(F1<S> f) {
        s.compare(this, f);
    }
}

Answer 3

问题在于a 的类型为A1<? extends F1<T>>，即由通配符参数化。然后就不能调用A1<?>.compare，因为编译器不知道? 代表什么具体类型。

对于这个更简单的代码，您会看到相同的行为：

A1<? extends Object> a = ...;
a.compare(new Object(), new Object());

---

如果我正确理解您的用例，您只希望能够在特定比较器上参数化 F1。所以看起来你应该能够做到这一点：

interface A1<A extends A1<A>> {
    public void compare(F1<A> f1, F1<A> f2);
}

class F1<A extends A1<A>> implements Comparable<F1<A>> {
    A a;
    @Override
    public void compareTo(F1<A> f) {
        a.compare(this, f);
    }
}

请注意，我已经让 F1 实现了 Comparable，因为这是很好的做法。