Как ограничить прием только одного типа в моем общем методе?

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

T часть означает, что все args будут такого же типа.

Если вы хотите ограничить общий тип быть только определенный тип или подтип (например, Integer), вы можете сделать следующее: -

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 2

Я не разработчик 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 3

Вы можете фактически сделать что-то вроде этого:

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! 
} 

Это имеет преимущество в том, что:

• Integer implements Comparable<Integer>
• Character implements Comparable<Character>
• String implements Comparable<String>
• Double implements Comparable<Double>

Так, чтобы соответствовать эти типы (и, возможно, другие), мы неизбежно T, как следует:

• T extends Comparable<T>

Это включает вещи, например, java.util.Date, который implements Comparable<Date>, и бесчисленное множество других типов, но, вероятно, это лучшее, что вы можете сделать, если вы также хотите разрешить Integer и Character.

---

Тем не менее, имейте в виду, что Integer, Character, String, являются все Object, поэтому на самом деле куча тех смешаны вместе IS список из одного типа: Object.

К счастью, это NOT корпус Object implements Comparable<Object>; в противном случае вышеуказанное решение не сработает.

Answer 4

Вы можете делать то, что вы хотите сделать так:

YourClass.<Type>foo(params); 

В частности:

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

и

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

Answer 5

Чтобы объявить ограниченный тип параметра, список параметра типа имя, за которым следует ключевое слово extends, а затем его верхняя граница.

Следующий метод будет принимать числа только в качестве параметров.

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

Если вы не продлить его Сопоставимые то compareTo() не будет доступен.