Encapsulation

1. Pengantar & Analogi Dunia Nyata

Pernah kebayang gak kalau nilai IPK kamu bisa diubah-ubah seenaknya sama teman yang iseng, cuma dengan inspect element atau nulis satu baris kode? Bahaya banget, kan?

Di dunia OOP, kita punya konsep Encapsulation. Ini mirip banget sama Portal Akademik kampus. Kamu gak bisa langsung ngubah angka di database nilai seenaknya. Kamu cuma bisa melihat nilai (get) atau mengubah nilai (set) lewat jalur resmi (Dosen -> Input Nilai -> Validasi Sistem).

2. Konsep Teknis

Encapsulation adalah mekanisme untuk menyembunyikan detail implementasi dari pengguna luar, dan hanya menyediakan antarmuka (interface) yang diperlukan.

Tujuannya:

1. Keamanan Data: Mencegah akses langsung ke variabel sensitif.
2. Validasi: Memastikan data yang masuk sesuai aturan.
3. Fleksibilitas: Kita bisa mengubah kode di dalam tanpa merusak kode di luar yang menggunakannya.

Read-Only vs Write-Only

Dengan Encapsulation, kita bisa mengontrol akses data secara granular:

• Read-Only: Cuma kasih Getter, jangan kasih Setter. (Contoh: NIM mahasiswa, sekali dibuat gak bisa diubah).
• Write-Only: Cuma kasih Setter, jangan kasih Getter. (Contoh: Upload Password baru, sistem simpan tapi gak boleh ditampilkan lagi).
• Full Access: Kasih Getter dan Setter. (Contoh: Alamat kos, bisa dilihat dan diubah).

3. Komponen Utama

A. Access Modifiers

Kata kunci untuk mengatur siapa yang boleh akses data/method ini:

B. Getter (Accessor)

Method public untuk membaca nilai variabel private. Biasanya diawali dengan kata get (atau is untuk boolean).

C. Setter (Mutator)

Method public untuk mengubah nilai variabel private. Di sinilah tempat kita menaruh logika validasi. Biasanya diawali dengan kata set.

4. Studi Kasus Koding (Java)

Mari kita bikin simulasi transkrip nilai (AcademicRecord) yang menerapkan konsep Read-Only pada NIM dan Validasi pada IPK.

File 1: AcademicRecord.java (Class)

public class AcademicRecord {
    // 1. DATA PRIVAT (Rahasia)
    private String nim;  // NIM bersifat Read-Only
    private String nama;
    private double ipk; 

    // 2. CONSTRUCTOR
    public AcademicRecord(String nim, String nama) {
        this.nim = nim; // NIM di-set sekali di awal
        this.nama = nama;
        this.ipk = 0.0;
    }

    // 3. GETTER (Akses Baca)
    
    // NIM cuma punya Getter, gak punya Setter -> READ ONLY
    public String getNim() {
        return this.nim;
    }

    public String getNama() {
        return this.nama;
    }

    public double getIpk() {
        return this.ipk;
    }

    // 4. SETTER (Akses Tulis dengan Validasi)
    
    // Setter cuma buat IPK, NIM gak boleh diubah!
    public void setIpk(double nilaiBaru) {
        // VALIDASI: IPK harus antara 0.0 sampai 4.0
        if (nilaiBaru >= 0.0 && nilaiBaru <= 4.0) {
            this.ipk = nilaiBaru;
            System.out.println("✅ Berhasil: IPK " + nama + " diperbarui menjadi " + nilaiBaru);
        } else {
            System.out.println("❌ Gagal: Nilai IPK tidak valid! Harus 0.0 - 4.0");
        }
    }
}

File 2: Main.java (Eksekusi)

public class Main {
    public static void main(String[] args) {
        AcademicRecord record = new AcademicRecord("12345", "Budi Santoso");

        // 1. COBA UBAH NIM (Ilegal)
        // record.nim = "99999"; // ❌ ERROR! Variable private.
        // record.setNim("99999"); // ❌ ERROR! Method tidak ada (Read-Only).

        // 2. AKSES LEWAT JALUR RESMI
        System.out.println("Mahasiswa: " + record.getNama() + " (" + record.getNim() + ")");
        
        // 3. Update IPK dengan Validasi
        record.setIpk(3.85);   // Output: ✅ Berhasil...
        record.setIpk(5.00);   // Output: ❌ Gagal...
        
        System.out.println("IPK Akhir: " + record.getIpk());
    }
}

5. Bedah Kode

1. private String nim;: Variabel nim dikunci rapat.
2. Tidak ada setNim(): Ini membuat nim bersifat Immutable (tak bisa diubah) setelah object dibuat lewat Constructor. Ini meniru dunia nyata: NIM tidak berubah sampai lulus.
3. public void setIpk(...): Ini adalah pintu masuk resmi. Di dalamnya ada if (nilaiBaru >= 0.0 && ...) yang bertindak sebagai satpam/validator. Kalau lolos, baru data diubah.
4. record.setIpk(5.0): Saat kita coba masukkan angka 5.0, validator menolak, sehingga nilai ipk asli tetap aman (3.85).

6. Latihan

Sebuah bank digital ingin meningkatkan keamanan sistem mereka. Saldo nasabah tidak boleh diubah secara langsung (di-hack), melainkan harus melalui proses validasi deposit yang sah.

Buatlah class BankAccount dengan spesifikasi berikut:

1. Attributes (Private)

• saldo (int): Menyimpan uang nasabah. Nilai awal 0.
• Wajib Private agar tidak bisa diakses langsung dari luar.

2. Method (Public)

• deposit(int jumlah):
  • Jika jumlah > 0: Tambahkan ke saldo, lalu cetak: Deposit berhasil. Saldo: <saldo>
  • Jika jumlah <= 0: Tolak transaksi, cetak: Deposit gagal! Jumlah harus lebih dari 0.
• getSaldo(): Mengembalikan nilai saldo saat ini.

Output yang Diharapkan

Kasus Valid:

Deposit berhasil. Saldo: 500000

Kasus Invalid:

Deposit gagal! Jumlah harus lebih dari 0.

7. Kesimpulan

Encapsulation itu soal kontrol. Kamu sebagai pembuat Class memegang kendali penuh atas data kamu.

• Gunakan private untuk data sensitif.
• Gunakan Getter/Setter untuk akses terkontrol.
• Hapus Setter jika ingin membuat data yang permanen (Read-Only).

Dengan begini, kode kamu jadi lebih aman, rapi, dan minim bug akibat data yang tidak valid.

Selanjutnya, kita akan belajar bagaimana cara mewariskan atribut dan method ke class lain tanpa harus menulis ulang kodenya: Inheritance.