Jak ograniczyć przyjmowanie tylko jednego typu w mojej ogólnej metodzie?

Question

Mam ogólną funkcję foo, która akceptuje dowolny typ i wypisuje je.

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

Jak upewnić się, że otrzymane argumenty mają tylko jeden typ. Na przykład {1, 'a', 3} powinno być nieprawidłowe. Powinno to być wszystkie liczby lub wszystkie znaki. Chcę zaakceptować dowolne liczby całkowite lub wszystkie znaki.

Answer 1

Część T oznacza, że ​​cały args będzie tego samego typu.

Jeśli chcesz zawęzić typu rodzajowego być tylko pewien typ lub podtyp (np Integer) można wykonać następujące czynności: -

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

nie jestem programista Java, ale to, czego można zrobić jako jednej z możliwych opcji jest użyć kolekcji rodzajowe obiektów typu 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

można faktycznie zrobić coś takiego:

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

ta wykorzystuje fakt, że:

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

tak, aby dopasować te rodzaje (i ewentualnie innych), mamy związane T jako to:

• T extends Comparable<T>

ta nie obejmuje rzeczy, na przykład java.util.Date, który jest niezliczoną liczbą innych typów, ale prawdopodobnie jest najlepszym, co możesz zrobić, jeśli chcesz zezwolić na Integer i Character.

---

Niemniej jednak, należy pamiętać, że Integer, Character, String, to wszystko Object, więc w rzeczywistości grono zmieszanych razem JEST lista jednego typu: Object.

Na szczęście jest to NOT w przypadku, że Object implements Comparable<Object>; w przeciwnym razie powyższe rozwiązanie nie zadziałałoby.

Answer 4

Możesz robić, co chcesz zrobić tak:

YourClass.<Type>foo(params); 

Konkretnie:

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

i

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

Answer 5

Aby zadeklarować ograniczone parametr typu, listy typ parametru nazwa, po której następuje słowo kluczowe extends, a następnie jego górna granica.

Następująca metoda przyjmuje tylko liczby zgodnie z parametrami.

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

Jeśli nie przedłużyć go o porównywalnym następnie compareTo() nie będzie dostępna.