0

我定义了一个抽象类如下：

public abstract class Move implements Comparable<Move> {
protected int cell;
protected int weight;       

public int getWeight()
{
    return this.weight;
}

public void setWeight(int value)
{
    this.weight = value;
}

protected Move(int cell)
{
    this.cell = cell;
    this.weight = 0;
}

protected Move(int cell, int weight)
{
    this.cell = cell;
    this.weight = weight;
}

@Override
public int compareTo(Move m) 
{
    return this.weight - m.weight;
}

我还有另外 2 个类扩展了这个类（分类为 MoveLeft 和 MoveRight）。我将这两种类型的对象都添加到 Move 类型的 List 中，然后使用 Collections.sort 进行排序：

List<Move> moves = new ArrayList<Move>(someSize);
moves.add(new MoveLeft(cell1));
moves.add(new MoveRight(cell2));
moves.add(new MoveRight(cell3));
moves.add(new MoveLeft(cell4));
Collections.sort(moves);

但是，列表是按单元格而不是按重量排序的。

不能在同一种类型中混合不同的子类实例吗？

注意：我在子类构造函数中为权重设置了一个唯一值。

4

2 回答 2

0

这真的是一个很长的评论，而不是一个答案。

我写了一个简单的测试程序，它似乎排序正确。输出是[Move [cell=10, weight=1], Move [cell=1, weight=100]]，既不是我添加元素的顺序，也不是单元格升序，而是权重升序。

我注意到您有两个相同类型的构造函数参数。我建议非常仔细地检查他们没有被调换。如果这不是问题，我建议尝试修改我的测试程序，使其更类似于真实代码，直到它重现问题为止。这是我的测试程序：

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

public class Test {
  public static void main(String[] args) {
    List<Move> list = new ArrayList<Move>();
    list.add(new MoveRight(1, 100));
    list.add(new MoveLeft(10, 1));
    Collections.sort(list);
    System.out.println(list);
  }
}

abstract class Move implements Comparable<Move> {
  protected int cell;
  protected int weight;

  public int getWeight()
  {
    return this.weight;
  }

  public void setWeight(int value)
  {
    this.weight = value;
  }

  protected Move(int cell)
  {
    this.cell = cell;
    this.weight = 0;
  }

  protected Move(int cell, int weight)
  {
    this.cell = cell;
    this.weight = weight;
  }

  @Override
  public int compareTo(Move m)
  {
    return this.weight - m.weight;
  }

  @Override
  public String toString() {
    return "Move [cell=" + cell + ", weight=" + weight + "]";
  }
}

class MoveLeft extends Move {

  protected MoveLeft(int cell, int weight) {
    super(cell, weight);
  }

}

class MoveRight extends Move {

  protected MoveRight(int cell, int weight) {
    super(cell, weight);
  }

}
于 2013-03-15T13:43:05.763 回答
0

您必须创建 Move 数组，并使用派生类将其向上转换为 Move 并像往常一样对其进行排序，然后您可以使用 istanceOf 和向下转换检查您的实际类。

于 2013-03-15T13:30:29.730 回答