Java泛型问题--要求测试，提供捕获，反之亦然

Question

我有一个抽象类：

public abstract class AbstractPoint<PointType extends AbstractPoint<PointType>> {
    public abstract double getX();
    public abstract double getY();
    public abstract double rho();

    // Find the distance between two points
    public final <T extends AbstractPoint<T>> double distance(T other) {
        return vectorTo(other).rho();
    }

    // Find vector from one point to another.
    public abstract <T extends AbstractPoint<T>> PointType vectorTo(T other);

    // other methods ...
}

类CommissionalPoint和PolarPoint扩展抽象类：

public class OrthogonalPoint extends AbstractPoint<OrthogonalPoint> {
    private double x;
    private double y;

    public OrthogonalPoint(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() { return this.x; }

    public double getY() { return this.y; }

    public double rho() { return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); }

    public double theta() { return Math.atan2(this.y, this.x); }

    public <T extends AbstractPoint<T>> OrthogonalPoint vectorTo(T other) {
        return new OrthogonalPoint(other.getX() - this.x, other.getY() - this.y);
    }
}

public class PolarPoint extends AbstractPoint<PolarPoint> {
    private double rho;
    private double theta;

    public PolarPoint(double x, double y) {
        this.rho = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        this.theta = Math.atan2(y, x);
    }

    public double getX() { return this.rho() * Math.cos(this.theta()); }

    public double getY() { return this.rho() * Math.sin(this.theta()); }

    public double rho() { return this.rho; }

    public double theta() { return this.theta; }

    public <T extends AbstractPoint<T>> PolarPoint vectorTo(T other) {
        return new PolarPoint(other.getX() - this.getX(), other.getY() - this.getY());
    }
}

使用这段代码，我可以正确地计算点之间的距离，无论它们是相同类型的（正交的还是极性的）。
现在我添加了另一个名为route:

public class Route {

    private final List<? extends AbstractPoint<?>> points = new ArrayList<>();

    // 'point' in 'this.points.add(point)' underlined red
    public <T extends AbstractPoint<T>> void appendPoint(T point) { this.points.add(point); }

    public <T extends AbstractPoint<T>> void removePoint(T point) { this.points.remove(point);  }

    // 'point' in '.distance(point)' underlined red
    public double routeDistance() {
        return this.points.stream().skip(1).mapToDouble(point ->
                this.points.get(this.points.indexOf(point) - 1).distance(point)).sum();
    }
}

路线是一个有序的点数，其长度定义为序列中点的距离之和。因此，如果一条路由由三个点(p1、p2和p3)组成，则该路由的距离为p1.距离(p2)+p2.距离(p3)。
但是，在我的代码中，有些地方（查看route中的注释）下划线为红色：

// in appendPoint function
Required type: capture of ? extends AbstractPoint<?>
     Provided: T

// in routeDistance function
Required type: T
     Provided: capture of ? extends AbstractPoint<?>

我希望能够将任何类型的点添加到points列表中，并调用routeDistance函数来计算路由的长度。我的解决方案有什么问题--我应该如何更改我的泛型（在任何类中）？

Answer 1

首先，请注意，您既要将数据添加到Points列表中，又要将数据从列表中取出，因此不应使用Extends或Super。（另见：胸肌）

private final List<AbstractPoint<?>> points = new ArrayList<>();

接下来，您将看到.dat距(point)调用出现错误。这是因为没有类型可以用作Distance方法的类型参数t，该类型也满足约束t extends abstractPoint 。请注意，Point的类型是AbstractPoint ，并且AbstractPoint 不能是T，因为AbstractPoint 不扩展AbstractPoint 。看到问题了吗？

据我所知，您编写distance的方式不允许您找到两个abstractPoint之间的距离。其中一个点必须是具体的类型。

事实上，Distance和VectorTo实际上并不需要泛型参数。它可以接受abstractPoint :

public final double distance(AbstractPoint<?> other) {
    return vectorTo(other).rho();
}

public abstract PointType vectorTo(AbstractPoint<?> other);

现在允许您将abstractPoint 传入Distract。

旁注：您当前使用indexof实现routeDistance的效率不是很高，因为它会对列表中的每个点遍历一次列表。您可以使用zip操作来代替。在链接的应答中使用zip方法：

return zip(points.stream(), points.stream().skip(1), AbstractPoint::distance)
    .mapToDouble(x -> x).sum();