Question

我正在尝试制作一个通用方法来比较多种类型的对象。

这是我的简单界面

interface comparable<T> {
    boolean isBiggerThan(T t1);
}

这是它的一个实现：

class StringComparable implements comparable<String> {

    public StringComparable(String s) {
        this.s = s;
    }

    String s;

    @Override
    public boolean isBiggerThan(String t1) {
        return s.equals(t1);
    }

}

这是我的类，它有一个通用的方法：

class Utilt {
    public static <T extends comparable<T>> int biggerThan(T values[], T t) {
        int count = 0;
        for (T oneValue : values) {
            if (oneValue.isBiggerThan(t)) {
                count++;
            }
        }
        return count;
    }
}

我称之为这样的方法：

public class TestTest {
    public static void main(String args[]) {
        StringComparable a = new StringComparable("Totti");
        StringComparable pi = new StringComparable("Pirlo");
        int i = Utilt.biggerThan(new StringComparable[] { a, pi }, a);
    }
}

但是我收到了这个错误：

The method `biggerThan(T[], T)` in the type `Utilt` is not applicable for the arguments `(StringComparable[], StringComparable)`

Answer 1

静态方法T的通用参数biggerThan必须实现comparable<T>。 StringComparable实现comparable<String>，而不是comparable<StringComparable>，因此它与静态方法的通用参数不匹配。

您可以通过更改StringComparable来实施comparable<StringComparable>来解决此问题。

class StringComparable implements comparable<StringComparable> {

    public StringComparable(String s) {
        this.s = s;
    }

    String s;

    @Override
    public boolean isBiggerThan(StringComparable t1) {
        return s.equals(t1.s);
    }

}

进行更改后，您的main会通过编辑并打印1。

那就是说，我不确定它对于一个被称为isBiggerThan的平等测试的方法有多大意义。

Answer 2

您的比较器接口需要String值而不是String数组。在调用该方法时，您正在传递StringComparable数组，因此它显示错误

Answer 3

注意!comparable<String> instanceof comparable<StringComparable>。所以尝试这样的事情：

class StringComparable implements comparable<StringComparable> {

  public StringComparable(String s) {
    this.s = s;
  }

  String s;

  public String getS(){
    return s;
  }

  @Override
  public boolean isBiggerThan(StringComparable t1) {
    return s.equals(t1.getS());
  }

}

和Utilt类

class Utilt {
    public static <T extends comparable<T>> int biggerThan(T values[], T t) {
        int count = 0;
        for (T oneValue : values) {
            if (oneValue.isBiggerThan(t)) {
                count++;
            }
        }
        return count;
    }
}

最好覆盖equals和hashCode，这样您就可以在this.equals(t1)方法中调用isBiggerThan。

BTW，方法isBiggerThan看起来非常可疑，只要：

StringComparable s1 = new StringComparable("string1");
StringComparable s2 = new StringComparable("string2");
s1.isBiggerThan(s2); // output => true
s2.isBiggerThan(s1); // output => true

这取决于你，但对我而言，这种逻辑看起来是错误的。

java调用泛型静态方法

3 个答案: