Java 带有捕获的泛型，can'；t转换

考虑以下数据类型：

import java.util.ArrayList;
import java.util.List;

public class MyList<T extends Comparable<T>> {
  protected List<T> data = new ArrayList<>();

  public void add(T v) {
    data.add(v);
  }
}

public interface IInterval<T extends Comparable<T>> extends Comparable<IInterval<T>> {

  T getBegin();

  T getEnd();

  @Override
  default public int compareTo(IInterval<T> other) {
    int c1 = getEnd().compareTo(other.getEnd());
    if (c1 == 0) {
      return getBegin().compareTo(other.getBegin());
    } else
      return c1;
  }
}

然后让我们举一个使用示例：

import java.util.List

class Interval implements IInterval<Integer> {
  private int begin, end;

  public Interval(int begin, int end) {
    this.begin = begin;
    this.end = end;
  }

  public Integer getBegin() {
    return begin;
  }

  public Integer getEnd() {
    return end;
  }
}

public class Test {
  public static void main(String[] args) {
    MyIntervalList<Integer> t = new MyIntervalList<>();
    t.add(new Interval(1, 10));

    List<Interval> l = t.getIntersect(1, 4);
  }
}

import java.util.List
类间隔实现IInterval{
开始，结束；
公共间隔（整数开始，整数结束）{
this.begin=开始；
this.end=end；
}
公共整数getBegin（）{
返回开始；
}
公共整数getEnd（）{
返回端；
}
}
公开课考试{
公共静态void main（字符串[]args）{
MyIntervalList t=新的MyIntervalList（）；
t、 添加（新间隔（1,10））；
列表l=t.getIntersect（1,4）；
}
}

当我编译此文件时，会出现以下错误：

Test.java:8: error: incompatible types: List<CAP#1> cannot be converted to List<Interval>
    List<Interval> l = t.getIntersect(1, 4);
                                     ^
  where CAP#1 is a fresh type-variable:
    CAP#1 extends IInterval<Integer> from capture of ? extends IInterval<Integer>
1 error

Test.java:8:错误：不兼容的类型：无法将列表转换为列表
列表l=t.getIntersect（1,4）；
^
其中CAP#1是一个新类型变量：
第1章延长了捕获的时间间隔？扩展区间
1错误

由于

Interval

实现了

IInterval

，

getIntersect

被声明为返回

？扩展IInterval

，其中

整数

被传递为

T

，我认为这是正确的方法，但显然我错了

---

有人能解释正确的方法吗？

首先调整

MyList

以允许它接受任何内容（它不需要将类型限制为

可比较的
）：

现在，编译器可以知道它处理的是哪种类型的间隔，并且会很高兴：

public static void main(String[] args) {
    MyIntervalList<Integer, Interval> t = new MyIntervalList<>();
    t.add(new Interval(1, 10));
    List<Interval> intersect = t.getIntersect(1, 4);
}

publicstaticvoidmain（字符串[]args）{
MyIntervalList t=新的MyIntervalList（）；
t、 添加（新间隔（1,10））；
List intersect=t.getIntersect（1,4）；
}
让我们假设你是对的。当
getIntersect
方法返回
ArrayList
的实例时（其中
Interval2
是
IInterval
的另一个实现），会发生什么情况？我意识到有一个问题。。。有没有关于如何正确执行此操作的建议？这取决于您的期望。如果您将变量的类型更改为
列表，该怎么办
class MyList<T> { 
    protected List<T> data = new ArrayList<>();

    public void add(T v) {
        data.add(v);
    }
}

class MyIntervalList<T extends Comparable<T>, I extends IInterval<T>> extends MyList<I> {
    public List<I> getIntersect(T begin, T end) {
        List<I> res = new ArrayList<>();
        for (I v : data) {
            if (v.getEnd().compareTo(begin) < 0 ||
                v.getBegin().compareTo(end) > 0) {
                res.add(v);
            }
        }
        return res;
    }
}

public static void main(String[] args) {
    MyIntervalList<Integer, Interval> t = new MyIntervalList<>();
    t.add(new Interval(1, 10));
    List<Interval> intersect = t.getIntersect(1, 4);
}