Typy generyczne w Javie: bezpieczne typowo klasy i metody

Po co są typy generyczne

Typ generyczny pozwala napisać kod raz i używać go dla wielu typów bez rezygnacji z bezpieczeństwa typów. Zamiast pisać osobno IntBox, StringBox i UserBox, piszesz jeden Box<T>, gdzie T to miejsce na typ, które wypełnia wywołujący.

Typy generyczne pojawiły się już za każdym razem, gdy w kodzie było ArrayList<String> albo HashMap w rodzaju HashMap<String, Integer>. Część <...> to argument typu. Ta strona pokazuje, jak pisać własne.

Alternatywa, czyli przechowywanie wszystkiego jako Object, wyrzuca informację o typie i wymusza brzydkie, podatne na błędy rzutowania:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("hello");
        raw.add(42);                       // nic nie powstrzyma tego błędu

        String first = (String) raw.get(0); // każdy odczyt wymaga rzutowania
        String oops = (String) raw.get(1);  // kompiluje się, a potem wywraca w czasie działania
        System.out.println(first + " " + oops);
    }
}

Rzutowanie w ostatnim wierszu rzuca ClassCastException w czasie działania programu, czyli dokładnie taki wyjątek, który typy generyczne mają uniemożliwić.

Klasa generyczna

Parametr typu deklarujesz w nawiasach ostrych po nazwie klasy. Zgodnie z konwencją to pojedyncza wielka litera: T od „type”, E od „element”, K/V od klucza i wartości.

class Box<T> {
    private T value;

    Box(T value) { this.value = value; }

    T get() { return value; }
    void set(T value) { this.value = value; }
}

public class Main {
    public static void main(String[] args) {
        Box<String> name = new Box<>("Coddy");
        Box<Integer> count = new Box<>(3);

        String s = name.get();     // bez rzutowania: kompilator wie, że to String
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // nie skompiluje się: Box<String> przyjmuje tylko Stringi
    }
}

Wewnątrz Box każde T staje się typem podanym przez wywołującego. Box<String> to pudełko, które przechowuje i zwraca tylko String. Kompilator odrzuca name.set(99), zanim program w ogóle się uruchomi.

Puste <> po prawej stronie (operator diamentu) pozwala kompilatorowi wywnioskować argument typu z lewej strony, więc nie powtarzasz <String> dwa razy.

Metody generyczne

Pojedyncza metoda może mieć własny parametr typu, niezależny od klasy. Umieść parametr <T> przed typem zwracanym:

import java.util.List;

public class Main {

    // <T> deklaruje parametr typu; T to typ elementu
    static <T> T firstOrNull(List<T> items) {
        return items.isEmpty() ? null : items.get(0);
    }

    public static void main(String[] args) {
        List<String> words = List.of("alpha", "beta");
        List<Integer> nums = List.of(10, 20, 30);

        String w = firstOrNull(words);   // T wywnioskowane jako String
        Integer n = firstOrNull(nums);   // T wywnioskowane jako Integer
        System.out.println(w + " " + n);
    }
}

Nigdy nie przekazujesz T jawnie: kompilator wnioskuje go z argumentu. Dzięki metodom generycznym narzędzia takie jak Collections.sort czy List.of pozostają bezpieczne typowo dla dowolnego typu elementów.

Parametry typu z ograniczeniem

Czasem typ generyczny ma sens tylko dla niektórych typów. extends ogranicza parametr, dzięki czemu możesz wywoływać metody typu ograniczającego. Tutaj T extends Number oznacza, że T to Number albo dowolna jego podklasa (Integer, Double, ...), więc dostępne jest doubleValue():

import java.util.List;

public class Main {

    static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue();   // dozwolone, bo T to co najmniej Number
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(List.of(1, 2, 3)));        // Integers
        System.out.println(sum(List.of(1.5, 2.5)));       // Doubles
    }
}

Zauważ, że extends oznacza tu „jest podtypem” i działa zarówno dla klas, jak i interfejsów: <T extends Comparable<T>> to bardzo częsty zapis, gdy trzeba porównywać elementy.

Wildcardy: ? extends i ? super

Subtelna pułapka: List<Integer> nie jest List<Number>, choć Integer jest Number. Typy generyczne są inwariantne. Wildcardy (symbole wieloznaczne) łagodzą to, gdy potrzebujesz tylko czytać albo tylko zapisywać.

Używaj ? extends T dla producenta, z którego czytasz, i ? super T dla konsumenta, do którego zapisujesz (zasada „PECS”: Producer Extends, Consumer Super):

import java.util.ArrayList;
import java.util.List;

public class Main {

    // odczytuje Numbers: przyjmuje List<Integer>, List<Double> itd.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // zapisuje Integers: przyjmuje List<Integer>, List<Number>, List<Object>
    static void addInts(List<? super Integer> dest) {
        dest.add(1);
        dest.add(2);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        System.out.println(total(ints));      // działa dzięki ? extends

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // działa dzięki ? super
        System.out.println(bucket);
    }
}

Lista ? extends Number pozwala czytać elementy jako Number, ale nie pozwala do niej dodawać (kompilator nie zna dokładnego typu elementów). Lista ? super Integer pozwala dodawać Integer, ale odczytane wartości mają typ Object. Dobierz wildcard do kierunku przepływu danych.

Wymazywanie typów i jego ograniczenia

Typy generyczne to mechanizm czasu kompilacji. Po kompilacji parametr typu zostaje wymazany: w czasie działania Box<String> i Box<Integer> to po prostu Box. Dzięki temu typy generyczne są zgodne wstecz ze starym kodem, ale wiąże się to z realnymi ograniczeniami.

// Żadne z tych się nie skompiluje: parametr typu nie istnieje w czasie działania:
T value = new T();          // nie można utworzyć instancji parametru typu
T[] array = new T[10];      // nie można utworzyć tablicy generycznej
if (list instanceof List<String>) { } // nie można sprawdzić argumentu typu

Ponieważ typu w czasie działania już nie ma, nie zapytasz przez refleksję „czym było T?” i nie przeciążysz metod, które różnią się tylko argumentem generycznym (foo(List<String>) i foo(List<Integer>) po wymazaniu mają tę samą sygnaturę). Gdy naprawdę potrzebujesz typu w czasie działania, przekaż token Class<T> jako parametr konstruktora lub metody.

Dalej: wyrażenia lambda

Jak widać, metoda generyczna przyjmuje typ jako parametr. Kolejny krok to traktowanie zachowania jako parametru. Wyrażenia lambda pozwalają przekazać do metody fragment kodu, czyli funkcję. Właśnie tak będziesz sortować, filtrować i przekształcać kolekcje generyczne, które potrafisz już bezpiecznie typować.