我一直在环顾四周,看看是否能找到可以帮助我解决问题的方法,但是到目前为止没有运气.我有以下课程：

  public interface ISort<T> {
      public List<T> sort(List<T> initialList);
  }


  public abstract class Sort<T> implements ISort<T> {
    private Comparator<? super T> comparator;

    public Sort(Comparator<? super T> comparator) {
        this.comparator = comparator;
    }

    @Override
    public List<T> sort(List<T> initialList) {
        ArrayList<T> list = new ArrayList<T>(initialList);
        Collections.sort(list, comparator);

        return list;
    }
  }


public abstract class InternalTreeItem<T> {   
    public abstract String getValue();
}

public class D extends InternalTreeItem<Integer> {
   private Integer i;

   public D(Integer i) {
       this.i = i;
   }

   @Override
   public String getValue() {
       return i.toString();
   }

   public Integer getInteger() {
       return i;
   }
}

public class DComparator implements Comparator<D> {
    @Override
    public int compare(D o1, D o2) {
        return o1.getInteger() - o2.getInteger();
    }
}

public class DSort extends Sort<D> {
    public DSort(Comparator<D> comparator) {
        super(comparator);
    }

    public DSort() {
        super(new DComparator());
    }
}

和测试类：

public class TestClass {
    @Test
    public void test1() {
        List<InternalTreeItem<?>> list= new ArrayList<InternalTreeItem<?>>();

        list.add(new D(1));
        list.add(new D(10));
        list.add(new D(5));

        ISort<?> sorter = new DSort();

        sorter.sort(list);       
    }
}

编译器在一行上给出错误

sorter.sort(list);

和状态

The method sort(List<capture#2-of ?>)
in the type ISort<capture#2-of ?>
is not applicable for the arguments
 (List<InternalTreeItem<?>>)

好的,经过几个小时并在朋友的帮助下,我们意识到问题出在抽象类Sort中的Collections#sort(List< T> list,Comparator&lt ;? super T> c),因为我使用了Comparator&lt ;?扩展T＞.

我使用泛型,因为我有2个模型,一个模型的超类是由35个类子类化的泛型抽象,而第二个模型实际上有2个不同的超类,这些超类组合在一起,又由35个类子类化.这些层次结构已给出,我无能为力对其进行修改.

这里的模型非常简单,但是您明白了.另外,还有一个工厂,该工厂根据T的类型返回一个分类器或另一个分类器.

任何人都可以帮忙,并为我的问题提供解决方案(即对通用列表进行排序；参数类型可以是通用超类或它的子类之一).

谢谢和最诚挚的问候,
多美

解决方法:

一种解决方法是对不能更改的类使用包装器类.

因此,在您的示例中,您要基于Integer值对对象D的列表进行排序.通过将对象放入包装器中,然后将其添加到列表中,可以公开希望对列表进行排序的值.

例如,您可以定义如下接口：

private interface SortableListItem<T> extends Comparable<SortableListItem<T>> {
    public T getValue();
}

然后,为D创建一个包装器类：

public class DWrapper implements SortableListItem<Integer> {
    private D item;

    public DWrapper(D item) {
        this.item = item;
    }

    public Integer getValue() {
        return item.getInteger();
    }

    public int compareTo(SortableListItem<Integer> o) {
        return getValue().compareTo(o.getValue());
    }
}

在这里,创建和排序列表非常简单：

    D item1= new D(1);
    D item2= new D(10);
    D item3= new D(5);

    DWrapper wrapper1 = new DWrapper(item1);
    DWrapper wrapper2= new DWrapper(item2);
    DWrapper wrapper3= new DWrapper(item3);

    List<SortableListItem<Integer>> sortableList = new  ArrayList<SortableListItem<Integer>>();
    sortableList.add(wrapper1 );
    sortableList.add(wrapper2);
    sortableList.add(wrapper3);
    Collections.sort(sortableList);

您当然可以使包装器类接受一个更通用的对象-关键是每个对象都返回一个可以对List进行排序的值(在这种情况下为Integer).