如何限制泛型类型(问题比看起来更难)

Question

好吧，问题并不像标题中看起来那么简单。

让我们从头开始。假设有两个包含DataRow对象的集合:

public class DataRow<K, V> {
    K key;
    V value;

    public DataRow(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}

伪代码示例如下:

c1 = [DataRow(0, "Italy"), DataRow(1, "Germany"), DataRow(2, "France")]
c2 = [DataRow(0, "Rome"), DataRow(1, "Berlin"), DataRow(3, "Budapest")]

在JoinedDataRow的一个集合中，需要有三种不同的方式连接这些集合（内部连接、左连接、右连接）：

public class JoinedDataRow<K, V1, V2> {
    K key;
    V1 value1;
    V2 value2;

    public JoinedDataRow(K key, V1 value1, V2 value2) {
        this.key = key;
        this.value1 = value1;
        this.value2 = value2;
    }

    public K getKey() {
        return key;
    }

    public V1 getValue1() {
        return value1;
    }

    public V2 getValue2() {
        return value2;
    }
}

操作类似于SQL语言中的操作。内连接的结果示例：[JoinedDataRow（0，"意大利"，"罗马"）， JoinedDataRow（1，"德国"，"柏林"）]

这些操作的实现有一个称为JoinOperation的接口:

public interface JoinOperation<D1, D2, R> {
    Collection<R> join(Collection<D1> leftCollection, Collection<D2> rightCollection);
}

其中 D1 和 D2 是 DataRow 的，R 是 JoinedDataRow（结果）

接口有3种实现：InnerJoin、LeftJoin、RightJoin

无需为所有三个实现提供代码。这只是InnerJoin的框架：

public class InnerJoinOperation<D1, D2, R> implements JoinOperation<D1, D2, R> {
    @Override
    public Collection<R> join(Collection<D1> leftCollection, Collection<D2> rightCollection) {
        return null;
    }
}

问题：例如，现在传递到整数的连接方法集合是可能的，也是完全合法的。

join（）方法应如下所示以避免：

@Override
    public Collection<JoinedDataRow<K, V1, V2>> join(Collection<DataRow<K, V1>> leftCollection, Collection<DataRow<K, V2>> rightCollection) {
        return null;
    }

但是禁止修改接口 JoinOperation，因此上述方法无效。

问题是:如何限制join方法中传递的参数的类型，这样就不可能传递除DataRow之外的任何内容。

我试过了:

public class InnerJoinOperation<D1 extends DataRow, D2 extends DataRow, R extends JoinedDataRow> implements JoinOperation<D1, D2, R> {
    @Override
    public Collection<R> join(Collection<D1> leftCollection, Collection<D2> rightCollection) {
        return null;
    }
}

但这里我使用的是原始数据行，当我想这样做时：

Collection<DataRow<Integer, String>> lCollection = new ArrayList<>(List.of(
                new DataRow<>(0, "Italy"),
                new DataRow<>(1, "Germany"),
                new DataRow<>(2, "France")
        ));

        Collection<DataRow<Integer, String>> rCollection = new LinkedList<>(List.of(
                new DataRow<>(0, "Rome"),
                new DataRow<>(1, "Berlin"),
                new DataRow<>(3, "Budapest")
        ));

        var joiner = new InnerJoinOperation<>();

        var joined = joiner.join(lCollection, rCollection);

expression < code > joiner . join(l collection，rCollection)显示编译时错误:在此输入图像描述

Answer 1

听起来你想要的只是

public class InnerJoinOperation<K, V1, V2>
    implements JoinOperation<DataRow<K, V1>, DataRow<K, V2>, JoinedDataRow<K, V1, V2>> {
  @Override
  public Collection<JoinedDataRow<K, V1, V2>> join(Collection<DataRow<K, V1>> leftCollection, Collection<DataRow<K, V2>> rightCollection) {
    return null;
  }
}