Kotlin Generic

Kalian pernah menulis logika kode yang sama persis berulang kali, hanya karena tipe datanya berbeda? Misalnya, satu fungsi untuk memproses Int, dan fungsi lain yang identik untuk memproses String ?

Di pertemuan ke 19 (Kalau tidak salah), kita akan mempelajari Kotlin Generics. Fitur ini memungkinkan kita menulis kode satu kali saja, namun bisa digunakan untuk berbagai tipe data yang berbeda tanpa mengorbankan keamanan kode (type safety) yang ada pada kotlin.

Apa yang akan Anda pelajari:

• Memahami konsep dasar dari Generic.
• Melihat perbedaan nyata antara kode Non-Generic vs Generic.
• Membuat Class dan Function sendiri menggunakan Generic.
• Menggunakan Generic dengan banyak tipe parameter (seperti pada Map).

Pengertian Generic

Secara sederhana, Generic adalah fitur yang memungkinkan kita menambahkan parameter tipe (type parameter) saat mendefinisikan sebuah Class, Interface, atau Function.

Jika parameter biasa di dalam fungsi digunakan untuk mengirimkan nilai (seperti 10 atau "Halo"), maka parameter Generic digunakan untuk mengirimkan jenis tipe data (seperti Int atau String).

Manfaat Generic

Mengapa menggunakan generic ?, Terdapat 2 alasan utama kenapa kita harus menggunakan generic

1. Type Safety: Error dideteksi saat kita menulis kode (compile-time), bukan saat aplikasi berjalan dan tiba-tiba crash (runtime).
2. Reusability: Tidak perlu menulis kode berulang untuk tipe data berbeda.

Contoh kode tanpa generic

Kita akan cobain dahulu, jadi silahkan buat file baru dengan nama KotlinTanpaGeneric.kt

class ExampleGeneric(val data: Any)

fun main() {
    val kotakAngka = ExampleGeneric(100)
    val kotakKata = ExampleGeneric("Halo")

    // Masalah 1: Kita harus melakukan casting manual (konversi tipe)
    // Kita harus memaksa compiler percaya bahwa data adalah Int
    val hasil = kotakAngka.data as Int
    println(hasil + 10)

    // Masalah 2: Rawan Error Runtime
    // Compiler tidak akan protes, tapi aplikasi akan CRASH saat dijalankan
    // karena kita mencoba mengubah String ("Halo") menjadi Int.
    val errorNanti = kotakKata.data as Int
}

Kelemahan kode di atas:

1. Compiler tidak tahu tipe data aslinya, jadi kita harus pakai as Int sebagai casting.
2. Jika salah casting, aplikasi akan force close (ClassCastException).

Contoh kode dengan generic

Kita akan buat file baru dengan nama KotlinGeneric.kt

// <T> adalah parameter tipe. Kita memberi tahu Kotlin:
// "Nanti saat kelas ini dipanggil, aku bakal kasih tahu T itu apo."
class ExampleGeneric1<T>(val data: T)

fun main() {
    // Kita tentukan T adalah Int
    val kotakAngka = ExampleGeneric1<Int>(100)

    // Kita tentukan T adalah String
    val kotakKata = ExampleGeneric1<String>("Halo")

    // Manfaat 1: Tidak perlu casting!
    // Kotlin sudah tahu bahwa kotakAngka.data PASTI Int.
    val hasil = kotakAngka.data
    println(hasil + 10)

    // Manfaat 2: Pengecekan Kompilasi
    // Baris di bawah ini akan ERROR MERAH di editor Anda sebelum dijalankan.
    // Kotlin mencegah Anda melakukan kesalahan.
    // val error = kotakKata.data + 10 // Error: Unresolved reference for String
}

Generic Class

Generic Class adalah blueprint kelas yang tipe datanya bisa berubah-ubah sesuai kebutuhan saat objek dibuat.

Cara membuatnya adalah dengan menambahkan <T> setelah nama kelas.

class MyData<T>(val firstData: T) {
    fun getData(): T {
        return firstData
    }

    fun printData() {
        println("Data is: $firstData")
    }
}

fun main() {
    // Menggunakan Generic Class dengan String
    val dataString = MyData<String>("Kelas IF71")
    dataString.printData()

    // Menggunakan Generic Class dengan Int
    val dataInt = MyData<Int>(2025)
    dataInt.printData()
}

Generic Function

Tidak hanya kelas, function juga bisa dibuat Generic. Ini sangat berguna jika kita memiliki logika fungsi yang sama tetapi inputnya bisa berbeda beda.

Posisi <T> diletakkan sebelum nama fungsi.

// Fungsi ini menerima parameter T dan mengembalikan T juga
fun <T> sayHello(param: T) {
    println("Halo, $param")
}

fun main() {
    // Memanggil fungsi generic
    sayHello("Budi")  // T otomatis menjadi String
    sayHello(123)     // T otomatis menjadi Int
    sayHello(true)    // T otomatis menjadi Boolean
}

Generic pada Map (Multi Type)

Struktur data Map adalah contoh penggunaan Generic dengan dua parameter tipe: Key (K) dan Value (V).

Misalnya kita ingin membuat kamus sederhana. Kunci pencariannya adalah kata (String), dan artinya juga sebuah kata (String). Atau daftar harga: Nama barang (String), Harga (Int).

fun main() {
    // Definisi: Map<K, V>
    // K (Key) kita set sebagai String
    // V (Value) kita set sebagai Integer
    val daftarHarga: Map<String, Int> = mapOf(
        "Apel" to 5000,
        "Jeruk" to 7000,
        "Mangga" to 12000
    )

    // Iterasi Generic Map
    // Kotlin otomatis tahu 'k' adalah String dan 'v' adalah Int
    for ((k, v) in daftarHarga) {
        println("$k harganya Rp $v")
    }
}

Penjelasan:

1. Map<String, Int>: Kita menentukan bahwa key wajib string dan value wajib int
2. Jika kita coba masukkan 100 to "Apel" (Key : Int dan Value : String), compiler akan langsung memberikan error

Contoh mendefinisikan atau membuat Multiple Type

Kita bisa lanjutkan pada file sebelumnya MultipleTypeGeneric.kt

// Kelas Pair sederhana yang menampung dua tipe berbeda
class ExampleMultipleType<T, U>(val pertama: T, val kedua: U)

fun main() {
    val status = ExampleMultipleType<String, Int>("Sukses", 200)
    println("Status: ${status.pertama}, Code: ${status.kedua}")
}

Generic Type dan Konvensi Penamaan pada Generic

"Kenapa harus huruf T?". Sebenarnya Anda bebas menggunakan huruf apa saja, bahkan kata panjang seperti <TipeData>. Namun, ada konvensi (aturan tidak tertulis) yang disepakati secara global agar kode mudah dibaca orang lain.

Berikut adalah nama parameter tipe yang umum:

Selesai

Terima kasih sampai jumpa