1. Memahami Asas Generik Java

Java Generics membolehkan anda menentukan kelas, antara muka dan kaedah dengan parameter jenis. Ini bermakna anda boleh menulis kod yang berfungsi dengan jenis data yang berbeza sambil memastikan keselamatan jenis pada masa penyusunan.

1.1 Apakah Generik?

Generik ialah ciri yang diperkenalkan dalam Java 5 yang membolehkan anda mentakrifkan kelas, antara muka atau kaedah dengan pemegang tempat untuk jenis data ia beroperasi. Ini membantu mencipta kelas dan kaedah yang boleh berfungsi dengan mana-mana jenis, sambil tetap menyediakan keselamatan jenis masa kompilasi.

Contoh:

public class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

Dalam contoh ini, T ialah parameter jenis yang boleh digantikan dengan mana-mana jenis data apabila anda mencipta tika Kotak.

1.2 Mengapa Menggunakan Generik?

Generik memberikan beberapa faedah:

• Keselamatan Jenis : Mereka menghapuskan keperluan untuk menghantar dan mengurangkan ralat masa jalan dengan menangkap jenis yang tidak sepadan pada masa penyusunan.
• Kebolehgunaan Semula Kod : Mereka membenarkan anda mencipta satu kelas atau kaedah yang boleh mengendalikan jenis data yang berbeza.
• Menghapuskan Penghantaran : Menggunakan generik mengurangkan keperluan untuk menghantar jenis, menjadikan kod anda lebih bersih dan kurang terdedah kepada ralat.

Contoh:

Tanpa Generik:

List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0); // Casting needed

Dengan Generik:

List<String> list = new ArrayList<>();
list.add("Hello");
String s = list.get(0); // No casting needed

2. Bekerja dengan Generik dalam Kelas

Generik boleh digunakan dengan kelas untuk memastikan keselamatan dan fleksibiliti jenis. Begini cara anda boleh menggunakan generik dalam definisi kelas dengan berkesan.

2.1 Contoh Kelas Generik

Pertimbangkan Pasangan kelas generik yang memegang dua nilai jenis yang mungkin berbeza:

public class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}

Dalam contoh ini, K dan V ialah parameter jenis yang boleh ditentukan semasa mencipta tika Pasangan.

Contoh Penggunaan:

Pair<String, Integer> pair = new Pair<>("Age", 30);
System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());

2.2 Parameter Jenis Terhad

Kadangkala, anda mungkin mahu mengehadkan jenis yang boleh digunakan dengan kelas atau kaedah generik. Parameter jenis terikat membolehkan anda menentukan julat jenis yang boleh diterima.

Contoh:

public class NumberUtils {
    public static <T extends Number> void printNumber(T number) {
        System.out.println("Number: " + number);
    }
}

Di sini, T dihadkan kepada subkelas Nombor, seperti Integer, Double, dsb.

Contoh Penggunaan:

NumberUtils.printNumber(10); // Valid
NumberUtils.printNumber(10.5); // Valid

3. Generik dalam Kaedah

Generik tidak terhad kepada kelas. Ia juga boleh digunakan dalam kaedah untuk mencipta kaedah yang fleksibel dan selamat jenis.

3.1 Contoh Kaedah Generik

Berikut ialah kaedah yang mengembalikan maksimum dua nilai:

public class Util {
    public static <T extends Comparable<T>> T max(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }
}

Dalam kaedah ini, T ialah parameter jenis yang mesti memanjangkan Comparable, memastikan T boleh dibandingkan.

Contoh Penggunaan:

public class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

3.2 Kad liar dalam Generik

Wildcard membolehkan anda menentukan julat jenis yang boleh diterima dengan cara yang lebih fleksibel. Contohnya, ? memanjang T menandakan jenis yang tidak diketahui yang memanjangkan T, manakala ? super T menandakan jenis yang tidak diketahui iaitu superjenis T.

Contoh:

List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0); // Casting needed

Contoh Penggunaan:

List<String> list = new ArrayList<>();
list.add("Hello");
String s = list.get(0); // No casting needed

4. Kesimpulan

Menguasai Java Generics boleh meningkatkan fleksibiliti dan keselamatan kod anda. Dengan memahami cara menggunakan generik dalam kelas, kaedah dan dengan kad bebas, anda akan dapat menulis kod yang lebih mantap dan boleh digunakan semula. Jika anda mempunyai sebarang pertanyaan atau memerlukan penjelasan lanjut, sila tinggalkan komen di bawah!

Baca siaran lebih lanjut di : Menguasai Generik Java: Panduan Komprehensif dengan Contoh Kod

Atas ialah kandungan terperinci Menguasai Generik Java: Panduan Komprehensif dengan Contoh Kod. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!