He hecho un ejemplo para demostrar mi problema:

Metrical.java

public interface Metrical<T>
{
    double distance(T other);
}

Widget.java

public class Widget implements Metrical<Widget>
{
    private final double value;

    public Widget(double value) { this.value = value; }

    public double getValue() { return value; }

    public double distance(Widget other) { return Math.abs(getValue() - other.getValue()); }
}

Pair.java

public class Pair<T>
{
    private final double value;
    private final T object1, object2;

    public Pair(T object1, T object2, double value)
    {
        this.object1 = object1;
        this.object2 = object2;
        this.value = value;
    }

    public T getObject1() { return object1; }

    public T getObject2() { return object2; }

    public double getValue() { return value; }
}

Algoritmo.java

import java.util.Set;

public class Algorithm<T extends Metrical<T>>
{
    public void compute(Set<T> objects)
    {

    }

    public void compute(Set<Pair<T>> pairs)
    {

    }
}

Entonces, enAlgoritmo.java, Establecer <Par <T >> está siendo visto como unConjunto <T> Y por eso estoy teniendo problemas de borrado de tipos. Sin embargo, ¿hay alguna manera de que pueda salir adelante con algo como esto sin nombrar los métodos de manera diferente? Ambas variantes del algoritmo están destinadas a operar enT's, pero necesito permitir diferentes argumentos. Ellos calculan la misma cosa, por lo que en un esfuerzo por evitar la confusión, preferiría no nombrarlos de manera diferente. ¿Hay alguna manera de acomodar esto?