Question

我有一个通用函数foo，它接受任何类型并打印出来。

public static <T> T foo(T... arg) {
    List<T> foo = Arrays.asList(arg);
    for (T t : foo) {
      System.out.println(t);
    }
    return null;
  }

如何确保收到的参数只有1种类型。例如，{1，'a'，3}应该无效。它应该是所有数字或所有字符。我想接受所有整数或所有字符。

Answer 1

你实际上可以这样做：

static <T extends Comparable<T>> void f(T... args) {
    System.out.println(java.util.Arrays.toString(args));
}
public static void main(String[] args) {
    // all one type -- all of these compile!
    f(1, 2, 3); // prints "[1, 2, 3]"
    f('a', 'b', 'c'); // prints "[a, b, c]"
    f("a", "b", "c"); // prints "[a, b, c]"
    f(1D, 2D, 3D); // prints "[1.0, 2.0, 3.0]"

    // this is not preventable
    f(1, (int)'a', 3); // prints "[1, 97, 3]"

    // mixture of types -- none of these compile!
    //f(1, 'a', 3); // compilation error!
    //f(1, '2', "3"); // compilation error!
    //f("a", "b", 'c'); // compilation error!
    //f(1, 2, 3D); // compilation error!
}

这利用了以下事实：

为了匹配这些类型（可能还有其他类型），我们绑定T如下：

T extends Comparable<T>

这包括例如java.util.Date，implements Comparable<Date>，以及无数其他类型，但如果您还想允许Integer和Character，则可能是最好的。

尽管如此，请注意Integer，Character，String都是Object，所以实际上是一堆混合在一起的 IS < / strong>一种类型的列表：Object。

值得庆幸的是，不 Object implements Comparable<Object>;否则上述解决方案将无效。

Answer 2

T部分表示所有args都属于同一类型。

如果您想将通用类型限制为仅某种类型或子类型（例如整数），您可以执行以下操作： -

public static <T extends Integer> T foo(T... arg) {
    List<T> foo = Arrays.asList(arg);
    for (T t : foo) {
      System.out.println(t);
    }
    return null;
  }

Answer 3

我不是一个java开发人员，但你可以选择使用类型为T的对象的泛型集合。

public static <T> T foo(List<T> arg) { 
    List<T> foo = arg; 
    for (T t : foo) { 
      System.out.println(t); 
    } 
    return null; 
  }

Answer 4

你可以这样做你想做的事情：

YourClass.<Type>foo(params);

具体做法是：

YourClass.<Integer>foo(1, 2, 3);

和

YourClass.<Character>foo('a', 'b', 'c');

Answer 5

您可以利用foo返回与输入参数相同的类型<T>这一事实。

您可以通过定义返回类型来推断<T>：

Integer i1 = 4;
String s = "string";

final Integer i2 = foo(i1, s); // error, only Integer allowed

如果您未指定返回类型，则类型<T>将被推断为Object，因此将接受所有子类。

或者，正如@Finbarr所提到的，您可以通过

推断出类型

Foo.<Integer>foo(i1, s); // error, only Integer allowed

Answer 6

要声明有界类型参数，请列出类型参数的名称，然后是extends关键字，后跟其上限。

以下方法只接受数字作为参数。

public static <T extends Comparable<T>> T maximum(T firstNumber, T secondNumber)
{                      
   system.out.println(secondNumber.compareTo(firstNumber));
}

如果您不使用Comparable扩展它，那么compareTo()将无法使用。

如何限制在我的通用方法中仅接受一种类型？

6 个答案: