Generics Java: Class dan Method yang Type-Safe

Kenapa Generics Ada

Tipe generic memungkinkanmu menulis kode sekali dan memakainya ulang untuk banyak tipe tanpa mengorbankan type safety. Daripada menulis IntBox, StringBox, dan UserBox secara terpisah, kamu menulis satu Box<T>, dengan T sebagai placeholder yang diisi oleh pemanggilnya.

Kamu sebenarnya sudah memakai generics setiap kali menulis ArrayList<String> atau HashMap seperti HashMap<String, Integer>. Bagian <...> itu adalah argumen tipe. Halaman ini menunjukkan cara menulis generics milikmu sendiri.

Alternatifnya, menyimpan semuanya sebagai Object, membuang informasi tipe dan memaksamu melakukan cast yang jelek dan rawan kesalahan:

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);                       // nothing stops this mistake

        String first = (String) raw.get(0); // every read needs a cast
        String oops = (String) raw.get(1);  // compiles, then crashes at runtime
        System.out.println(first + " " + oops);
    }
}

Cast di baris terakhir itu melempar ClassCastException saat runtime, jenis exception yang memang dirancang untuk dibuat mustahil oleh generics.

Generic Class

Deklarasikan type parameter di dalam kurung sudut setelah nama class. Menurut konvensi, namanya berupa satu huruf besar: T untuk "type", E untuk "element", K/V untuk key/value.

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();     // no cast - the compiler knows it's a String
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // won't compile - Box<String> only accepts Strings
    }
}

Di dalam Box, setiap T menjadi tipe apa pun yang diberikan pemanggilnya. Box<String> adalah kotak yang hanya menyimpan dan mengembalikan String. Compiler menolak name.set(99) bahkan sebelum programnya berjalan.

Tanda <> kosong di sebelah kanan (disebut diamond operator) membuat compiler menyimpulkan argumen tipe dari sisi kiri, jadi kamu tidak perlu menulis <String> dua kali.

Generic Method

Satu method bisa punya type parameter sendiri, terlepas dari class-nya. Taruh parameter <T> sebelum tipe return:

import java.util.List;

public class Main {

    // <T> declares the type parameter; T is the element type
    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 inferred as String
        Integer n = firstOrNull(nums);   // T inferred as Integer
        System.out.println(w + " " + n);
    }
}

Kamu tidak pernah mengirim T secara eksplisit, karena compiler menyimpulkannya dari argumen. Generic method adalah cara utilitas seperti Collections.sort atau List.of tetap type-safe untuk tipe elemen apa pun.

Bounded Type Parameter

Kadang tipe generic hanya masuk akal untuk sebagian tipe. extends membatasi parameternya sehingga kamu bisa memanggil method dari batas tersebut. Di sini T extends Number berarti T adalah Number atau subclass-nya (Integer, Double, ...), sehingga doubleValue() tersedia:

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();   // legal because T is at least a 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
    }
}

Perhatikan bahwa extends di sini berarti "merupakan subtipe dari", dan berlaku untuk class maupun interface. <T extends Comparable<T>> sangat sering dipakai saat kamu perlu membandingkan elemen.

Wildcard: ? extends dan ? super

Ada jebakan yang halus: List<Integer> bukan List<Number>, meskipun Integer adalah Number. Generics bersifat invariant. Wildcard melonggarkan aturan ini saat kamu hanya perlu membaca atau hanya perlu menulis.

Pakai ? extends T untuk producer yang kamu baca datanya, dan ? super T untuk consumer yang kamu tulisi data (aturan "PECS", Producer Extends, Consumer Super):

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

public class Main {

    // reads Numbers out - accepts List<Integer>, List<Double>, etc.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // writes Integers in - accepts 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));      // works thanks to ? extends

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // works thanks to ? super
        System.out.println(bucket);
    }
}

List ? extends Number memungkinkanmu membaca elemen sebagai Number, tetapi tidak bisa ditambahi (compiler tidak bisa tahu tipe elemen yang persis). List ? super Integer memungkinkanmu menambahkan Integer, tetapi hasil bacaannya kembali sebagai Object. Pilih wildcard yang sesuai dengan arah aliran datanya.

Type Erasure dan Batasannya

Generics adalah fitur saat kompilasi. Setelah dikompilasi, type parameter-nya dihapus: saat runtime, Box<String> dan Box<Integer> sama-sama hanya Box. Ini membuat generics tetap kompatibel dengan kode lama, tetapi menimbulkan batasan yang nyata.

// None of these compile - the type parameter doesn't exist at runtime:
T value = new T();          // can't instantiate a type parameter
T[] array = new T[10];      // can't create a generic array
if (list instanceof List<String>) { } // can't test the type argument

Karena tipenya hilang saat runtime, kamu tidak bisa bertanya "tadi T itu apa?" lewat reflection, dan kamu tidak bisa melakukan overload pada method yang hanya berbeda argumen generic-nya (foo(List<String>) dan foo(List<Integer>) dihapus menjadi signature yang sama). Kalau kamu benar-benar butuh tipenya saat runtime, kirim token Class<T> sebagai parameter constructor atau method.

Berikutnya: Lambda Expression

Kamu sudah melihat bahwa generic method menerima tipe sebagai parameter. Langkah berikutnya adalah menjadikan perilaku sebagai parameter. Lambda expression memungkinkanmu mengirim sepotong kode, yaitu sebuah fungsi, ke dalam method. Persis dengan cara itulah kamu akan mengurutkan, menyaring, dan mengubah collection generic yang baru saja kamu pelajari cara memberinya tipe dengan aman.