Interface, Abstract Class, Enum & Record

Abstraksi

Abstraksi berarti fokus pada apa yang dilakukan, bukan bagaimana. Java punya dua alat utama: interface dan abstract class.

Interface — kontrak

Interface mendefinisikan kontrak: daftar method yang wajib dimiliki class yang mengimplementasikannya.

interface Bentuk {
    double luas();                 // otomatis public abstract
    default String info() {        // default method (Java 8+) punya isi
        return "Luas = " + luas();
    }
}

class Persegi implements Bentuk {
    private final double sisi;
    Persegi(double sisi) { this.sisi = sisi; }

    @Override
    public double luas() { return sisi * sisi; }
}

class Lingkaran implements Bentuk {
    private final double r;
    Lingkaran(double r) { this.r = r; }

    @Override
    public double luas() { return Math.PI * r * r; }
}

Bentuk b = new Persegi(4);
System.out.println(b.info());    // Luas = 16.0

• Satu class boleh implements banyak interface (class A implements X, Y).
• Method di interface otomatis public; implementasinya di class harus ditulis public.
• Field di interface otomatis public static final (konstanta).
• Interface tidak bisa di-new, tetapi variabelnya boleh bertipe interface (polimorfisme).

Abstract class — setengah jadi

abstract class Karyawan {
    protected String nama;
    Karyawan(String nama) { this.nama = nama; }

    abstract double hitungGaji();          // wajib diisi subclass

    void cetakSlip() {                     // method biasa, sudah ada isinya
        System.out.println(nama + ": " + hitungGaji());
    }
}

class Tetap extends Karyawan {
    Tetap(String nama) { super(nama); }
    @Override
    double hitungGaji() { return 5_000_000; }
}

Enum — kumpulan nilai tetap

Gunakan enum saat nilai yang mungkin sudah pasti dan terbatas: status pesanan, hari, arah, level.

enum Status { BARU, DIPROSES, SELESAI }

Status s = Status.BARU;
if (s == Status.BARU) { System.out.println("Pesanan baru"); }

String teks = switch (s) {
    case BARU -> "Menunggu";
    case DIPROSES -> "Sedang dikerjakan";
    case SELESAI -> "Tuntas";
};

for (Status x : Status.values()) System.out.println(x + " #" + x.ordinal());
Status dariTeks = Status.valueOf("SELESAI");

Enum bisa punya field, constructor, dan method:

enum Level {
    PEMULA(1), MENENGAH(2), AHLI(3);

    private final int bobot;
    Level(int bobot) { this.bobot = bobot; }
    public int getBobot() { return bobot; }
}

Keuntungan dibanding String/int bebas: tidak bisa salah ketik, compiler membantu mengecek switch yang lengkap, dan kode lebih mudah dibaca.

Record — data ringkas (Java 16+)

Class yang hanya membawa data biasanya butuh banyak kode (field, constructor, getter, equals, hashCode, toString). Record menggantinya dalam satu baris:

record Titik(int x, int y) { }

Titik p = new Titik(3, 4);
System.out.println(p.x());        // 3  (accessor tanpa "get")
System.out.println(p);            // Titik[x=3, y=4]
System.out.println(p.equals(new Titik(3, 4)));   // true

Record bersifat immutable (field final). Kamu boleh menambah validasi lewat compact constructor:

record Umur(int nilai) {
    Umur {
        if (nilai < 0) throw new IllegalArgumentException("Umur negatif");
    }
}

Kapan memakai apa?

• Perlu kontrak/kemampuan lintas class → interface.
• Induk bersama dengan state dan kode berbagi → abstract class.
• Pilihan terbatas dan tetap → enum.
• Pembawa data sederhana yang tak berubah → record.