Polimorfisme Java: Satu Interface, Banyak Bentuk

Satu Referensi, Banyak Tipe

Polimorfisme adalah hasil yang kamu petik dari inheritance dan interface. Artinya, satu variabel yang bertipe parent (atau interface) bisa berisi objek dari subtipe mana pun, dan saat kamu memanggil method padanya, Java menjalankan versi milik class asli objek itu, bukan versi yang tersirat dari tipe variabel yang dideklarasikan.

Kamu sudah melihat dasarnya di halaman inheritance: subclass meng-override method dari parent-nya. Polimorfisme membuat override itu berguna: kamu bisa menulis kode untuk tipe umumnya dan membiarkan setiap objek konkret berperilaku dengan caranya sendiri.

class Animal {
    String speak() { return "..."; }
}

class Dog extends Animal {
    String speak() { return "Woof"; }
}

class Cat extends Animal {
    String speak() { return "Meow"; }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // a parent reference holding a child object
        Animal b = new Cat();

        System.out.println(a.speak());   // Woof
        System.out.println(b.speak());   // Meow
    }
}

a dan b sama-sama dideklarasikan sebagai Animal, tetapi masing-masing mencetak suaranya sendiri. Pilihan itu terjadi saat runtime berdasarkan objek yang sebenarnya.

Dynamic Method Dispatch

Mekanisme di baliknya disebut dynamic method dispatch: untuk method instance yang di-override, JVM melihat class runtime objek untuk memutuskan implementasi mana yang dipanggil. Compiler hanya memeriksa bahwa method itu ada di tipe yang dideklarasikan; pemilihan sebenarnya ditunda sampai program berjalan.

Inilah yang membuat satu loop bisa menangani campuran banyak tipe tanpa pernah bertanya tipe masing-masing:

import java.util.List;

class Shape {
    double area() { return 0; }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    double area() { return Math.PI * r * r; }
}

class Square extends Shape {
    private final double side;
    Square(double side) { this.side = side; }
    double area() { return side * side; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Square(2), new Circle(3));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // each call dispatches to the real subclass
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Loop itu hanya tahu tentang Shape. Kalau nanti kamu menambahkan Triangle extends Shape, kode ini tetap berjalan tanpa diubah, dan memang itulah intinya. Kode bergantung pada abstraksinya, bukan pada daftar tipe konkretnya.

Upcasting dan Downcasting

Menyimpan Dog di variabel Animal disebut upcasting, yaitu naik di hierarki ke tipe yang lebih umum. Ini selalu aman dan Java melakukannya secara implisit, karena setiap Dog adalah Animal.

Arah sebaliknya disebut downcasting, yaitu mengambil referensi parent dan memperlakukannya sebagai subtipe tertentu. Ini adalah bentuk type casting antar tipe referensi, dan hanya valid kalau objeknya memang subtipe itu. Jadi kamu harus menulis cast-nya secara eksplisit, dan kamu berisiko terkena ClassCastException kalau salah:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal { }

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // upcast - implicit, safe

        Dog d = (Dog) a;        // downcast - explicit, valid because a is really a Dog
        d.fetch();

        Animal c = new Cat();
        Dog wrong = (Dog) c;    // compiles, but throws ClassCastException at runtime
        wrong.fetch();
    }
}

Cast terakhir lolos kompilasi, karena compiler tidak bisa membuktikan bahwa cast itu salah, tetapi gagal saat dijalankan karena Cat bukan Dog. Jangan pernah melakukan downcast hanya berdasarkan keyakinan.

Lindungi Downcast dengan instanceof

Sebelum downcasting, cek tipe aslinya dengan instanceof. Java modern memungkinkanmu mengikat hasilnya di ekspresi yang sama (pattern matching untuk instanceof), jadi kamu tidak perlu cast terpisah:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal {
    void scratch() { System.out.println("scratching"); }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = { new Dog(), new Cat(), new Dog() };

        for (Animal animal : animals) {
            if (animal instanceof Dog dog) {     // checks type AND binds dog
                dog.fetch();
            } else if (animal instanceof Cat cat) {
                cat.scratch();
            }
        }
    }
}

instanceof mengembalikan false untuk null, jadi pengecekan ini juga melindungimu dari NullPointerException. Meski begitu, kalau kamu mendapati dirimu menulis rantai instanceof yang panjang, sering kali itu tanda bahwa perilakunya seharusnya berada di dalam class sebagai method yang di-override. Biarkan polimorfisme yang melakukan percabangan untukmu.

Overriding vs Overloading

Keduanya terdengar mirip tetapi tidak berhubungan, dan tertukar di antara keduanya adalah sumber kebingungan yang klasik.

Overriding adalah subclass yang mengganti method parent dengan signature yang identik. Pemilihannya terjadi saat runtime berdasarkan tipe objek, dan inilah polimorfisme yang sejak tadi kita pakai.

Overloading adalah satu class yang punya beberapa method dengan nama sama tetapi daftar parameter berbeda. Pemilihannya terjadi saat kompilasi berdasarkan tipe argumen, tanpa ada dispatch saat runtime:

public class Main {
    static String describe(int x)    { return "int: " + x; }
    static String describe(double x) { return "double: " + x; }
    static String describe(String x) { return "String: " + x; }

    public static void main(String[] args) {
        System.out.println(describe(5));      // int: 5
        System.out.println(describe(5.0));    // double: 5.0
        System.out.println(describe("five")); // String: five
    }
}

Compiler memilih describe yang cocok murni dari tipe statis argumennya. Tidak ada objek parent/child yang terlibat, jadi ini bukan polimorfisme runtime, melainkan sekadar memakai ulang nama method.

Jebakan Umum: Field Tidak Polimorfik

Hanya method instance yang dipilih saat runtime. Field dan method static ditentukan berdasarkan tipe yang dideklarasikan, dan ini menjebak banyak orang:

class Parent {
    String label = "parent";
    String name() { return "Parent"; }
}

class Child extends Parent {
    String label = "child";          // hides, does not override
    String name() { return "Child"; }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.label);    // parent  - field uses declared type
        System.out.println(p.name());   // Child   - method uses runtime type
    }
}

p.name() menjalankan versi milik Child (polimorfisme), tetapi p.label membaca field milik Parent, karena field itu disembunyikan (hidden), bukan di-override. Solusinya sederhana: jadikan field private dan akses hanya lewat method, supaya pemanggilan polimorfik selalu menang.

Berikutnya: Access Modifier

Polimorfisme hanya berjalan mulus kalau subclass bisa melihat dan meng-override member yang tepat, sementara bagian lain dari kodemu tidak bisa masuk dan merusak aturan yang harus dijaga. Keseimbangan itu diatur oleh akses public, protected, private, dan package-private, yaitu access modifier, yang dibahas berikutnya.