Belajar OOP dengan Java - Abstraction: Abstract Class & Interface

#Pendahuluan

Empat pilar OOP kita akhiri di pilar yang paling strategis: abstraction — memisahkan "apa yang bisa dilakukan" dari "bagaimana melakukannya". Java memberi dua senjata: abstract class dan interface. Memilih di antara keduanya dengan tepat adalah salah satu skill desain yang paling sering ditanyakan di dunia kerja.

Mengapa episode ini penting? Karena hampir semua framework Java yang kalian temui — Spring, Hibernate, koleksi Java — dibangun di atas kontrak abstraction. Kemampuan membaca dan merancang kontrak inilah yang membedakan programmer yang menyalin kode dari programmer yang mendesain sistem.

#Abstract Class

#Apa itu Abstract Class?

Abstract class adalah class yang tidak bisa di-instantiate — tidak bisa new langsung. Ia menjadi kerangka bagi subclass. Tandanya: keyword abstract pada class dan/atau method.

Abstract class dengan implementasi parsial

public abstract class Akun {
    protected String pemilik;
    protected double saldo;
 
    public Akun(String pemilik, double saldo) {
        this.pemilik = pemilik;
        this.saldo = saldo;
    }
 
    public void deposit(double nominal) {
        saldo += nominal;
    }
 
    public abstract void laporan();
}

Perhatikan dua bagian:

• Method konkret (deposit) — implementasi yang diwarisi semua subclass. Ini "shared state & partial implementation".
• Method abstract (laporan()) — hanya kontrak; subclass wajib mengimplementasikannya.

#Subclass Menyelesaikan Kontrak

Subclass wajib implementasikan abstract method

public class RekeningTabungan extends Akun {
    public RekeningTabungan(String pemilik, double saldo) {
        super(pemilik, saldo);
    }
 
    @Override
    public void laporan() {
        System.out.println("Tabungan " + pemilik + ": " + saldo);
    }
}

Kekuatan abstract class: state dibagikan (field pemilik, saldo) dan implementasi umum dibagi (deposit). Subclass hanya menambahkan yang spesifik. Ini cocok ketika class-class terkait berbagi banyak hal nyata.

#Interface

#Kontrak Murni

Interface adalah kontrak tanpa state. Di Java modern, interface mendeklarasikan method (dan beberapa bentuk default/static/private), dan class menandatangani kontrak dengan implements.

Interface kontrak murni

public interface Pembayaran {
    boolean proses(double nominal);
}

Implementasi kontrak

public class TransferBank implements Pembayaran {
    @Override
    public boolean proses(double nominal) {
        System.out.println("Transfer bank " + nominal);
        return true;
    }
}

Perbedaan kunci dari abstract class: interface tidak punya state. Ia hanya mendefinisikan perilaku. Karena itu satu class bisa implements banyak interface, tetapi hanya bisa extends satu class — Java tidak punya multiple inheritance untuk class.

#Default, Static, dan Private Method

Sejak Java 8, interface tidak lagi "hampa":

• default method — implementasi default yang bisa di-override implementor. Diciptakan agar interface bisa berkembang tanpa memecah implementor lama.
• static method — helper milik interface, dipanggil lewat nama interface.
• private method — helper internal yang dipakai bersama default/static method, tidak terlihat luar.

Default, static, dan private method

public interface Pembayaran {
    boolean proses(double nominal);
 
    default void prosesDenganLog(double nominal) {
        log("Memulai pembayaran " + nominal);
        proses(nominal);
        log("Selesai");
    }
 
    static void log(String pesan) {
        System.out.println("[LOG] " + pesan);
    }
}

default memberi fleksibilitas evolusi tanpa merusak implementor — ini yang dipakai Java Collections saat menambah method ke List di Java 8.

#Kapan Memilih Mana?

Ini pertanyaan favorit saat wawancara kerja:

Aturan praktis dari banyak codebase modern: mulai dengan interface untuk kontrak, gunakan abstract class hanya saat benar-benar butuh berbagi state. Kalian bahkan bisa menggabungkan: interface mendefinisikan kontrak, abstract class menyediakan implementasi dasar yang meng-implements interface itu.

100%

#Sealed Interface dan Hierarki Tertutup

#Masalah Hierarki Terbuka

Interface biasa terbuka: class apa pun bisa implements dari mana saja. Kadang kita ingin hierarki tertutup — hanya tipe tertentu yang boleh. Di sinilah sealed bekerja:

Sealed interface membatasi implementor

public sealed interface Bentuk
    permits Lingkaran, Persegi, Segitiga {
    double luas();
}

Hanya Lingkaran, Persegi, dan Segitiga yang boleh mengimplementasikannya. Tipe lain di luar permits akan error compile. Keuntungannya: ketika kalian menulis switch atas Bentuk, compiler bisa memastikan semua kasus tercakup — tidak ada cabang yang terlupakan (dipakai penuh dengan pattern matching di episode 10).

#Anti-Pattern: Interface Raksasa

Interface yang terlalu banyak method memaksa implementor menulis method yang tidak relevan — misal Pembayaran punya proses() dan juga gantiPIN() yang hanya berlaku untuk kartu. Ini melanggar Interface Segregation (episode 14). Pecah kontrak per peran:

Interface terpecah per peran

public interface Pembayaran {
    boolean proses(double nominal);
}
 
public interface GantiPIN {
    void gantiPIN(String pinLama, String pinBaru);
}

Class KartuDebit meng-implements dua-duanya; TransferBank cukup yang pertama. Interface kecil lebih mudah diuji, dipakai ulang, dan dipahami.

#Penutup

Inti yang harus dibawa pulang:

• Abstract class: punya state dan implementasi parsial, tidak bisa new; subclass menyelesaikan method abstract.
• Interface: kontrak murni tanpa state; satu class bisa implements banyak interface.
• Interface modern punya default, static, dan private method untuk evolusi yang aman.
• Mulai dengan interface untuk kontrak; abstract class hanya saat butuh berbagi state nyata.
• sealed interface membatasi hierarki — cocok dengan pattern matching.

Di episode 10 selanjutnya kita akan membahas enum, record & sealed class — tipe data yang merepresentasikan kumpulan konstan, data carrier immutable, dan hierarki class tertutup, plus switch pattern matching. Sampai jumpa di episode 10!