Belajar Java - OOP Dasar & Class Design

#Pendahuluan

Inilah inti dari seluruh bahasa Java: Object-Oriented Programming. Episode 6 membahas OOP dasar dan desain class — cara Java memodelkan dunia nyata menjadi objek yang memiliki data dan perilaku. Konsep ini bukan sekadar fitur, melainkan gaya berpikir yang membentuk seluruh ekosistem Java.

Kalian akan mempelajari enkapsulasi untuk melindungi data, inheritance dan polymorphism untuk membangun hierarki class, abstract class untuk kerangka kerja, serta interface modern untuk mendesain kontrak. Setelah episode ini, kalian akan mendesain class yang bersih dan mudah dirawat.

#Konsep Objek dan Class

#Class sebagai Cetak Biru

Class adalah cetak biru yang mendefinisikan atribut dan perilaku. Objek adalah instance nyata dari class tersebut. Contoh sederhana:

public class Produk {
    String nama;
    double harga;
 
    void tampilkan() {
        System.out.println(nama + " seharga " + harga);
    }
}

Untuk membuat objek, gunakan keyword new:

Produk kopi = new Produk();
kopi.nama = "Kopi Arabika";
kopi.harga = 45000;
kopi.tampilkan();

new Produk() mengalokasikan objek di heap dan memanggil constructor default.

#Enkapsulasi, Accessor, dan Mutator

#Melindungi Data dengan private

Enkapsulasi membungkus data sehingga hanya bisa diakses lewat method yang terkontrol. Field dibuat private, lalu diakses melalui accessor (getter) dan diubah melalui mutator (setter):

public class Rekening {
    private double saldo;
 
    public double getSaldo() {
        return saldo;
    }
 
    public void setor(double jumlah) {
        if (jumlah > 0) {
            saldo += jumlah;
        }
    }
}

Dengan mutator, kalian bisa menambahkan validasi — setoran negatif ditolak. Ini adalah contoh desain class yang baik.

#Inheritance dan Polymorphism

#Inheritance: Pewarisan

Inheritance memungkinkan class mewarisi member dari class lain menggunakan keyword extends. Class turunan bisa menimpa method induk dengan @Override:

public class Kendaraan {
    public void bergerak() {
        System.out.println("Kendaraan bergerak");
    }
}
 
public class Mobil extends Kendaraan {
    @Override
    public void bergerak() {
        System.out.println("Mobil melaju");
    }
}

#Polymorphism: Banyak Bentuk

Polymorphism berarti satu referensi bisa menunjuk ke objek dari tipe berbeda. Method yang dipanggil ditentukan saat runtime:

Kendaraan k = new Mobil();
k.bergerak();  // memanggil versi Mobil

#Abstract Class dan Interface

#Abstract Class sebagai Kerangka

Abstract class tidak bisa di-instantiate; ia menyediakan kerangka yang wajib dilengkapi subclass. Method abstrak tidak punya implementasi dan harus di-override:

public abstract class Bentuk {
    public abstract double luas();
}
 
public class Persegi extends Bentuk {
    private double sisi;
 
    public Persegi(double sisi) {
        this.sisi = sisi;
    }
 
    @Override
    public double luas() {
        return sisi * sisi;
    }
}

#Interface Modern dan Default Method

Interface mendefinisikan kontrak yang harus diimplementasikan. Sejak Java 8, interface bisa memiliki default method (dengan implementasi) dan static method:

public interface Pembayaran {
    void bayar(double jumlah);
 
    default void cetakStruk() {
        System.out.println("Struk dicetak");
    }
 
    static void verifikasiSistem() {
        System.out.println("Sistem OK");
    }
}

Class yang mengimplementasikan interface ini wajib menyediakan bayar, tetapi boleh memakai cetakStruk bawaan.

#Functional Interface

Interface dengan tepat satu method abstrak disebut functional interface — menjadi dasar lambda expression:

@FunctionalInterface
public interface Predikat {
    boolean uji(int nilai);
}
 
Predikat lebihDariSepuluh = n -> n > 10;
System.out.println(lebihDariSepuluh.uji(25));

Lambda n -> n > 10 menggantikan implementasi anonim secara ringkas. Pola ini dipakai luas di Stream API dan framework modern.

#Penutup

Episode 6 membangun pondasi OOP Java: memahami class dan objek, menerapkan enkapsulasi dengan accessor dan mutator, membangun hierarki dengan inheritance dan polymorphism, menggunakan abstract class sebagai kerangka, serta merancang kontrak dengan interface modern dan functional interface.

Inti yang harus dibawa pulang:

• Class adalah cetak biru; objek dibuat dengan new.
• Enkapsulasi melindungi data lewat getter dan setter.
• Inheritance memakai extends; polymorphism mengarahkan pemanggilan saat runtime.
• Abstract class menyediakan kerangka yang wajib diimplementasikan.
• Interface modern mendukung default dan static method.
• Functional interface memungkinkan lambda untuk satu method abstrak.

Di episode 7 selanjutnya kita akan membahas exception handling dan debugging dasar — struktur exception checked dan unchecked, blok try-catch-finally, try-with-resources, rethrow exception, membuat custom exception, serta teknik debugging di IDE dan membaca stack trace. Saatnya membuat kode yang tangguh!