Typy generyczne w Javie: var, Optional, sealed

Dzięki var pomijasz typ zmiennej lokalnej. Java wyprowadza go z wartości po prawej stronie =: var names = new ArrayList<String>(); ma typ ArrayList<String>. Typ jest potem tak samo ustalony jak zwykle, tylko nie jest zapisany. Przy var typ w nawiasach ostrych piszesz po prawej stronie. var działa też w pętli for-each, ale nie dla pól i parametrów.

Zmienna typu Object może zawierać wszystko. instanceof sprawdza, co jest w środku, i od razu daje ci pasującą zmienną: w if (value instanceof String s) zmienna s jest w bloku if typu String, bez rzutowania.

1import java.util.ArrayList;2import java.util.List;3
4public class Main {5    public static String describe(Object value) {6        if (value instanceof String s) {7            return "Text with " + s.length() + " characters";8        } else if (value instanceof Integer i) {9            return "Integer, doubled " + (i * 2);10        }11        return "Something else";12    }13
14    public static void main(String[] args) {15        var names = new ArrayList<String>();16        names.add("Ada");17        names.add("Linus");18        for (var name : names) {19            System.out.println(name.toUpperCase());20        }21        var count = names.size();22        System.out.println("Count: " + count);23
24        List<Object> things = List.of("hello", 21, 3.5);25        for (var thing : things) {26            System.out.println(describe(thing));27        }28    }29}

class Box<T> ma parametr typu T. Wewnątrz klasy używasz T jak zwykłego typu. Dopiero przy tworzeniu obiektu ustala się, czym jest T: w Box<String> to String, w Box<Integer> to Integer. Dzięki temu piszesz pudełko raz, a get() i tak zwraca właściwy typ. Rekordy też mogą mieć parametry typu, nawet kilka: record Pair<A, B>(A first, B second).

Także pojedyncza metoda może mieć parametr typu. Stoi on przed typem zwracanym:

1public static <T extends Comparable<T>> T smallest(List<T> list)

T extends Comparable<T> oznacza: T musi dać się porównywać. Tylko wtedy możesz w metodzie wywołać compareTo. Metoda działa z liczbami, tekstami i każdą własną klasą, która implementuje Comparable.

1import java.util.List;2
3class Box<T> {4    private T content;5
6    public void put(T content) {7        this.content = content;8    }9
10    public T get() {11        return content;12    }13}14
15record Pair<A, B>(A first, B second) {16}17
18public class Main {19    public static <T extends Comparable<T>> T smallest(List<T> list) {20        T best = list.get(0);21        for (T element : list) {22            if (element.compareTo(best) < 0) {23                best = element;24            }25        }26        return best;27    }28
29    public static void main(String[] args) {30        Box<String> word = new Box<>();31        word.put("Java");32        String w = word.get();33        System.out.println(w.length());34
35        Box<Integer> number = new Box<>();36        number.put(7);37        int n = number.get();38        System.out.println(n + 1);39
40        Pair<String, Integer> entry = new Pair<>("Ada", 36);41        System.out.println(entry);42
43        System.out.println(smallest(List.of(5, 2, 9)));44        System.out.println(smallest(List.of("pear", "apple", "fig")));45    }46}

Co ma zwrócić wyszukiwanie, które niczego nie znalazło? O sprawdzeniu null łatwo zapomnieć. Optional<T> pokazuje już w typie, że wartości może nie być. Zawiera albo wartość (Optional.of(x)), albo jest pusty (Optional.empty()).

• isPresent() sprawdza, czy wartość istnieje
• orElse(fallback) zwraca wartość albo wartość zastępczą
• map(...) przekształca zawartość, jeśli jakaś jest; pusty zostaje pusty (podobnie jak w strumieniach w Javie)

1import java.util.List;2import java.util.Optional;3
4public class Main {5    public static Optional<String> firstStartingWith(List<String> words, char letter) {6        for (String w : words) {7            if (w.charAt(0) == letter) {8                return Optional.of(w);9            }10        }11        return Optional.empty();12    }13
14    public static void main(String[] args) {15        List<String> fruits = List.of("apple", "banana", "cherry");16        Optional<String> b = firstStartingWith(fruits, 'b');17        Optional<String> z = firstStartingWith(fruits, 'z');18
19        System.out.println(b.isPresent());20        System.out.println(b.orElse("none"));21        System.out.println(z.orElse("none"));22        System.out.println(b.map(String::length).orElse(0));23        System.out.println(z.map(String::length).orElse(0));24    }25}

sealed interface Payment permits Cash, Card, Voucher ustala: istnieją dokładnie te trzy rodzaje Payment i żadne inne. Wtedy switch może decydować bezpośrednio według rodzaju:

• case Voucher v -> sprawdza rodzaj i daje ci obiekt jako v
• case Cash(double amount) -> od razu rozpakowuje rekord (wzorzec rekordu, record pattern)
• when dodaje warunek: case Cash(double amount) when amount >= 100 ->

Ponieważ kompilator zna wszystkie dozwolone rodzaje, switch nie potrzebuje default. Jeśli brakuje jakiegoś przypadku, kompilator to zgłosi. Tak jak przy else if, wygrywa pierwszy pasujący przypadek. Dlatego bardziej szczegółowy przypadek z when musi stać pierwszy.

1sealed interface Payment permits Cash, Card, Voucher {2}3
4record Cash(double amount) implements Payment {5}6
7record Card(double amount, String bank) implements Payment {8}9
10record Voucher(String code) implements Payment {11}12
13public class Main {14    public static String describe(Payment p) {15        return switch (p) {16            case Cash(double amount) when amount >= 100 -> "Large cash payment: " + amount;17            case Cash(double amount) -> "Cash: " + amount;18            case Card(double amount, String bank) -> "Card from " + bank + ": " + amount;19            case Voucher v -> "Voucher " + v.code();20        };21    }22
23    public static void main(String[] args) {24        System.out.println(describe(new Cash(20)));25        System.out.println(describe(new Cash(150)));26        System.out.println(describe(new Card(35.5, "Sparkasse")));27        System.out.println(describe(new Voucher("SUMMER10")));28    }29}