Question

我有一个需要调用SportsMenComparator的静态方法。但是，我们都知道这是不允许的。静态函数如何使用比较器子类？虽然我有解决方法，但我正在寻找针对这一特定问题的最佳实践。

final class SportsMan {

    private final String name;
    private final int rank;
    private final String sport;

    public SportsMan (String name, int rank, String sport)  {
        this.name = name;
        this.rank = rank;
        this.sport = sport;
    }

    public String getName() {
        return name;
    }

    public int getRank() {
        return rank;
    }

    public String getSport() {
        return sport;
    }
}


final class Sport {

    private final String sport;
    private final int numberOfPlayers;

    public Sport(String sport, int numberOfPlayers) {
        this.sport = sport;
        this.numberOfPlayers = numberOfPlayers;
    }

    public String getSport()  {
        return sport;
    }

    public int getNumberOfPlayers() {
        return numberOfPlayers;
    }
}


public final class Joins {

    private Joins () {}



    public class SportsMenComparator implements Comparator<SportsMan> {
        @Override
        public int compare(SportsMan s1, SportsMan s2) {
            return s1.getSport().compareTo(s2.getSport());
        }
     }



    public static void innerJoinSort(List<SportsMan> sportsMans, List<Sport> sportList) {
        Collections.sort(sportsMans, new SportsMenComparator());

    }


}

Eclipse会产生以下消息：No enclosing instance of type Joins is accessible其中Joins是封闭类的名称。

Answer 1

但是，我们都知道这是不允许的。静态函数如何使用比较器子类？

您不能使用非静态reference，但您仍然可以创建新对象并使用它。因此，既然您正在创建一个新的SportsMenComparator对象并且没有问题。

例如：

public static void main(String[] args) {
            List<String> s =new ArrayList<String>();
            s.add(""); // allowed
        }

但是

List<String> s =new ArrayList<String>();
        public static void main(String[] args) {
            System.out.println();
            s.add(""); // Error: Cannot make a static reference to the non-static field s
        }

编辑：

由于您在连接中定义了比较器类，因此需要Joins对象来访问其中的比较

Collections.sort(sportsMans, new Joins().new SportsMenComparator());

Answer 2

对于使用比较器，从静态或非静态方法使用它没有区别。在任何一种情况下都必须使用比较器的实例。

现代JVM的垃圾收集器在处理短期对象方面非常有效。因此，每次使用新实例（通过新实例）所要支付的罚款通常都不成问题。但是，如果您不想每次都使用新实例，我认为最好的选择是向SportsMenComparator添加一个静态字段，其中包含比较器的单例实例：

public class SportsMenComparator implements Comparator<SportsMan> {
  public static final SportsMenComparator instance=new SportsMenComparator();
  @Override
  public int compare(SportsMan s1, SportsMan s2) {
    return s1.getSport().compareTo(s2.getSport());
  }
}

public static void innerJoinSort(List<SportsMan> sportsMans, List<Sport> sportList) {
  Collections.sort(sportsMans, SportsMenComparator.instance);
}

Answer 3

问题是您尝试在静态方法中访问实例元素（在这种情况下，它是一个类，实际上与字段或方法相同），该方法与实例无关。 SURESH ATTA的答案是正确的，但你也可以让你的SportsMenComparator类保持静态，它会起作用。我没有任何理由将您的比较器与Joins类的实例相关联。

Answer 4

可以使用这样的东西---

public static boolean someMethod(MyObject obj1, MyObject obj2){
    return obj1.compare(obj2);
}

Answer 5

为什么你不能在函数中包含参数。

public static void innerJoinSort(List<SportsMan> sportsMans, List<Sport> sportList, Comparator comparator) {
    Collections.sort(sportsMans, comparator);
}

静态方法如何使用比较器？

5 个答案: