Generic Types

Di tulisan sekarang, kita bakal bahas dikit tentang Generic Types. Apa itu generic types?! Inti dari generic types itu… sebuah tipe data yang dapat dimasukin nilai apapun. Bingung?! Baiklah… kita mulai dari konsep variabel.

Bayangkan sekarang kamu punya variabel di kode kamu masing-masing. Gambaran dari variabel adalah sebuah kotak yang memiliki kesepatakan terhadap “apa yang disimpan” dalam kotak tersebut, dan juga “jenis yang disimpan”. Contohnya, kamu punya kotak untuk menyimpan jenis-jenis sepatu, maka hal yang harus kamu simpan adalah sepatu. Hal yang kamu simpan bisa sepatu olahraga, sepatu high heel buat ke pesta, atau bahkan sepatu barbie kamu… yang penting, isinya sepatu. Akan salah besar kalau kamu simpan koleksi tas kamu dalam kotak yang dimaksudkan untuk menyimpan sepatu.

Itu konsep variabel… sekarang, bayangkan, ketika ada seseorang yang bakal menggunakan kotak tersebut. Pastinya, orang itu mau menyimpan sesuatu. Tapi… bukan sepatu lah yang mau ia simpan. Dia butuh kotak untuk menyimpan bundle-an revisi TA dari dosen pembimbing-nya. Efeknya, kotak sepatu yang tersedia, udah ga berguna lagi. Dia harus membuat kotak baru untuk menyimpan revisian2 itu. Ga efektif kan?! Harus bikin dari awal, padahal kotak sepatu masih bisa nutup lhah buat nyimpen dokumen semacam revisian TA dengan segala coretan di dalamnya.

Dan di sinilah Generic Types bekerja dengan caranya… memastikan bahwa sebuah variabel dapat menampung nilai dengan fleksibel.

Implementasi generic types yang paling gampang dilihat yaitu di penggunaan Collections dari bahasa pemrograman Java. Contoh paling gampang, di Array List. Pada saat menggunakan array list, kamu bisa menambahkan berbagai elemen dengan tipe data yang berbeda.

import java.util.ArrayList;

public class TipeUmum {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("hai, ini blog");
al.add("arby");
al.add(3);
System.out.println(al);
}
}
//hasil eksekusi: [hai, ini blog, arby, 3]

Lihat contoh di atas kan… Di array list bernama al, kita menambahkan 2 data dengan 2 objek yang berbeda. Tipe berupa string, dan tipe berupa angka (integer). Artinya, untuk implementasi kode array list, programmer-nya pakai tipe generic untuk mengkodekan sifat-sifat dari si list. Dan tipe ini fleksibel banget. Karena selain memberikan kemudahan, tipe ini juga bisa dibuat strict. Contohnya:

import java.util.ArrayList;

public class TipeUmum {
public static void main(String[] args) {
ArrayList<Integer> al = new ArrayList();
al.add("hai, ini blog");
al.add(" arby");
al.add(3);
System.out.println(al);
}
}

//kode di atas error, tidak dapat dikompilasi
//baris yang dicoret: baris penyebab error

Kode di atas, itu ga jauh beda dari sebelumnya. Perbedaannya, ada pada penulisan ArrayList<Integer>. Hal ini ga dipunya oleh kode yang sebelumnya. Dan begitulah cara untuk membuat array list strict dalam penggunaannya. Tentang hal ini, ada terkait dengan type erasure yang dilakukan oleh java compiler.. tapi ga usah kita bahas lhah yang itu ya.

Balik lagi ke inti tulisan kita, ArrayList di atas adalah contoh penggunaan tipe umum atau Generic Types. Dan sekarang, seandainya kita akan membuat sebuah implementasi dari generic types, gimana caranya?! Anggap kita mau membuat sebuah struktur data “circular linked list” dengan sifatnya sendiri, tapi data yang diberikan bisa beda-beda… untuk hal ini, kita butuh generic.

Implementasi generic itu dasarnya gampang banget, kamu cuma perlu mengganti setiap tipe data dari variabel yang kamu tuliskan menjadi sebuah huruf kapital. Contoh, kamu punya variabel “int data”, tinggal ganti jadi “T data” atau “D data”. Setelahnya, tambahkan huruf capital tersebut di dekat nama class, diapit dengan diamond. Contohnya, kalau tadi kamu ganti tipenya jadi T, dan ini ada di kelas bernama Box, maka tuliskan “Box<T>“. Hurufnya bisa apapun, yang penting kapital. Iya, itu aja cukup. Cuma, ada kesepakatan dalam konvensi developer, untuk penggunaan huruf kapital, harus mewakili hal-hal berikut:

  1. Untuk mewakili elemen, tuliskan E;
  2. Untuk mewakili kunci elemen (key), tuliskan K;
  3. Untuk mewakili nomor (number), tuliskan N;
  4. Untuk mewakili tipe tertentu (type), tuliskan T;
  5. Untuk mewakili nilai tertentu (value), tuliskan V;
  6. Untuk mewakili parameter 2, 3, 4, dst, tuliskan S, U, V, dst.

Tapi lagi-lagi… hal di atas cuma kesepakatan yah… enggak wajib. Sekarang, kodenya gimana?! Untuk mencoba belajar melihat sifat generic, kita butuh perbandingan antara kode non-generic-types dengan yang generic-types. Dan ini kode yang non-generic-types:

public class Kotak {
    private int barang;

    public void set(int barang) { 
        this.barang = barang; 
    }
    public int get() { 
        return barang; 
    }
}

Untuk menggunakan class di atas, kode main yang mungkin dibuat adalah

public static void main(String[] args) {
Kotak k1 = new Kotak();
k1.set(5);

Kotak k2 = new Kotak();
k2.set(10);
}

Bandingkan dengan penulisan kode dari generic types dari kotak di atas:

public class KotakG<T> {
    private T barang;

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

Untuk menggunakan class KotakG di atas, kode main yang mungkin dituliskan adalah:

public static void main(String[] args) {
KotakG k1 = new KotakG();
k1.set(5);

KotakG k2 = new KotakG();
k2.set("Revisi TA");
}

Lihat kan yah… di sini, kamu dapat memasukkan 2 tipe data yang berbeda dalam objek yang dibentuk dari class yang sama. Hal ini ga akan kamu bisa lakukan di class Kotak (yang tidak menggunakan konsep generic).

Kode lengkapnya untuk yang KotakG gini:

public class KotakG<T> {
    private T barang;

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

    public static void main(String[] args) {
        KotakG k1 = new KotakG();
        k1.set(5);
        System.out.println("Isi kotak k1: "+k1.get());

        KotakG k2 = new KotakG();
        k2.set("Revisi TA");
        System.out.println("Isi kotak k2: "+k2.get());
    }
}

Hasil akhirnya:

Isi kotak k1: 5
Isi kotak k2: Revisi TA

Daaaan.. begitulah. Generic Types ini banyak dibahas kalau udah ngebahas mata kuliah struktur data pakai bahasa Java. Karena, di mata kuliah itu, kita bakal bikin linked list, doubly linked list, circular linked list, tree, graph, dll, dsb dengan data yang disimpan bersifat fleksibel. Bahkan bisa bertipe objek.

FYI, generic types yang kita bahas ini sebenarnya cetek yah… yaaaa, khas nya tulisan blog balita lhah.. kamu bisa lihat berbagai hal lain di sumber-sumber yang saya cantumkan di bawah ini. Dan sekarang, sekian tulisan tentang generic types.. happy learning.

Sumber:

https://docs.oracle.com/javase/tutorial/java/generics/index.htm

https://www.tutorialspoint.com/java/java_generics.htm

https://docs.oracle.com/javase/tutorial/extra/generics/index.html

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s