Belajar OOP dengan Java - Polymorphism

#Pendahuluan

Di episode 7 kita melihat overriding sebagai cara subclass menimpa perilaku superclass. Episode ini melebarkan lensa: polymorphism — kemampuan satu pesan menghasilkan banyak bentuk perilaku. Inilah pilar yang membuat OOP benar-benar "bernyawa", dan inilah yang membedakan kode yang harus di-edit berkali-kali dari kode yang bisa diperluas dengan menambahkan class baru.

Mengapa polymorphism adalah keterampilan paling berharga di series ini? Karena hampir semua desain modern — interface, strategy pattern, dependency injection, framework seperti Spring — berdiri di atasnya. Episode 8 adalah fondasi teknisnya.

#Dua Jenis Polymorphism

#Compile-time: Method Overloading

Sudah kita lihat di episode 5: beberapa method dengan nama sama, parameter berbeda. Compiler memilih yang tepat berdasarkan tipe argumen sebelum program berjalan:

Polymorphism compile-time

public class Formatter {
    String format(int angka) {
        return "Angka: " + angka;
    }
 
    String format(String teks) {
        return "Teks: " + teks;
    }
 
    String format(int angka, boolean panjang) {
        return panjang ? "Angka detail: " + angka : "Angka: " + angka;
    }
}

format(42) vs format("halo") vs format(42, true) — kompiler sudah tahu method mana yang dipanggil. Nol biaya runtime, tetapi juga nol fleksibilitas: tipe sudah ditentukan.

#Runtime: Overriding dan Dynamic Dispatch

Inilah polymorphism yang sebenarnya. Kunci dari dynamic dispatch: method yang dieksekusi ditentukan oleh tipe object yang sebenarnya saat runtime, bukan tipe variabelnya.

Overriding menuju dynamic dispatch

public class Hewan {
    void suara() {
        System.out.println("...");
    }
}
 
public class Kucing extends Hewan {
    @Override
    void suara() {
        System.out.println("Meong");
    }
}
 
public class Anjing extends Hewan {
    @Override
    void suara() {
        System.out.println("Guk");
    }
}

Sekarang bagian ajaibnya:

Satu pesan, banyak perilaku

public class Main {
    public static void main(String[] args) {
        Hewan hewan = new Kucing();
        hewan.suara();   // Meong — bukan "..."
 
        Hewan hewan2 = new Anjing();
        hewan2.suara();  // Guk
    }
}

Variabel bertipe Hewan, tetapi object sebenarnya Kucing — dan Java memanggil method Kucing.suara() karena keputusan diambil saat runtime. Inilah dynamic dispatch: pemanggil hanya tahu "saya mengirim pesan suara ke Hewan", dan setiap object menjawab dengan caranya sendiri.

#Program to Interface

#Dari Tipe Konkret ke Tipe Abstrak

Pola paling kuat: deklarasikan variabel/parameter dengan tipe yang paling abstrak, isi dengan object konkret. Ini disebut program to interface.

Program to interface

public interface Kendaraan {
    void jalan();
}
 
public class Motor implements Kendaraan {
    public void jalan() {
        System.out.println("Motor berjalan");
    }
}
 
public class Kapal implements Kendaraan {
    public void jalan() {
        System.out.println("Kapal berlayar");
    }
}

Pemakai tidak peduli implementasi

public class Main {
    public static void main(String[] args) {
        Kendaraan kendaraan = new Motor();
        kendaraan.jalan();
    }
}

Kekuatan sebenarnya: kode yang memakai Kendaraan tidak perlu diubah ketika implementasi baru muncul. Tambah class Pesawat implements Kendaraan — pemanggil tetap kendaraan.jalan(). Tanpa polymorphic thinking, menambah jenis kendaraan berarti menulis if (jenis == Motor) {...} else if (jenis == Kapal) {...} — dan itulah spiral kode yang memburuk.

#Polymorphic Collections

Collection Java (detail lengkap di episode 11) memakai polymorphism ini: deklarasikan collection dengan tipe umum, isi dengan berbagai subclass.

Satu collection, banyak tipe

import java.util.ArrayList;
import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        List<Hewan> kebunBinatang = new ArrayList<>();
        kebunBinatang.add(new Kucing());
        kebunBinatang.add(new Anjing());
        kebunBinatang.add(new Kucing());
 
        for (Hewan hewan : kebunBinatang) {
            hewan.suara();
        }
    }
}

Output:

Meong
Guk
Meong

Perhatikan: satu loop yang sama menangani tiga object berbeda tanpa satu pun if untuk membedakan tipe. Menambah jenis hewan baru = menambah class baru, tanpa menyentuh loop. Ini pola yang akan kalian lihat berulang di SOLID (episode 14) dan design patterns (episode 15).

#Kenapa Bukan if/else?

Kode berbasis if (instanceof ...) menumbuhkan cabang setiap kali ada jenis baru — melanggar Open/Closed Principle (episode 14). Polymorphism membalik arah: alih-alih pemanggil memeriksa jenis, setiap object tahu jawabannya sendiri. Hasilnya kode pemanggil tetap stabil saat domain tumbuh.

#Kesalahan Umum

#instanceof Berlebihan

Kadang instanceof memang perlu (misal type safety di kasus tertentu), tetapi jika dipakai untuk menggantikan polymorphism, itu bau kode:

Anti-pattern: cabang instanceof

public class Main {
    static void bunyi(Object hewan) {
        if (hewan instanceof Kucing k) {
            k.suara();
        } else if (hewan instanceof Anjing a) {
            a.suara();
        }
    }
}

Setiap hewan baru = tambah cabang baru. Bandingkan dengan polymorphic call hewan.suara() yang tidak pernah berubah. Episode 21 akan menunjukkan cara menyingkirkan cabang-cabang ini lewat refactoring.

#Overloading vs Overriding Tertukar

• Overloading: nama sama, parameter beda → diputuskan saat compile.
• Overriding: nama & parameter sama persis → diputuskan saat runtime.

Dua-duanya polymorphism, tetapi titik keputusannya berbeda. Ingat: overriding butuh @Override; overloading tidak.

#Penutup

Inti yang harus dibawa pulang:

• Polymorphism compile-time = overloading (keputusan saat compile).
• Polymorphism runtime = overriding + dynamic dispatch (keputusan saat runtime).
• Method yang dipanggil ditentukan tipe object sebenarnya, bukan tipe variabel.
• Program to interface: deklarasikan abstrak, isi konkret — pemakai tidak perlu tahu implementasi.
• Polymorphic collections + loop = menghilangkan if/else berantai dan mendukung pertumbuhan domain.

Di episode 9 selanjutnya kita akan membahas abstraction: abstract class & interface — kapan memakai mana, method default/static/private di interface, dan sealed interface. Sampai jumpa di episode 9!