PBO Pemrograman Berorientasi ObjekSimulasi interaktif · Python

Topik 03 dari 6

Encapsulation

Sembunyikan, lalu kendalikan aksesnya

Encapsulation membungkus data bersama method yang mengolahnya, lalu menyembunyikan detail internal. Akses hanya lewat pintu resmi yang sudah divalidasi.

Encapsulation (pembungkusan) berarti menyatukan data dengan method yang mengolahnya, lalu membatasi akses langsung ke data tersebut. Tujuannya bukan merahasiakan, melainkan menjaga data tetap valid: perubahan hanya boleh lewat jalur yang sudah diperiksa.

1Masalah tanpa encapsulation

Jika atribut bisa diubah bebas dari luar, tidak ada yang mencegah nilai yang mustahil, misalnya saldo negatif.

Contoh
class Rekening:
    def __init__(self, saldo):
        self.saldo = saldo

r = Rekening(100000)
r.saldo = -999999      # tidak ada yang menghalangi
print(r.saldo)
Output
-999999

Aturan seperti "saldo tidak boleh negatif" disebut invarian. Encapsulation memastikan invarian selalu terjaga, apa pun yang dilakukan kode di luar class.

2Tingkat akses di Python

Python tidak punya kata kunci private seperti Java. Sebagai gantinya ada konvensi penamaan:

PenulisanSifatArtinya
saldoPublikBebas dipakai dari mana saja.
_saldoProtected (konvensi)"Urusan internal, jangan disentuh dari luar." Tetap bisa diakses.
__saldoPrivate (name mangling)Nama diubah otomatis menjadi _NamaClass__saldo sehingga sulit diakses tak sengaja.
Contoh
class Rekening:
    def __init__(self, saldo):
        self.__saldo = saldo

    def lihat_saldo(self):
        return self.__saldo

r = Rekening(100000)
print(r.lihat_saldo())

try:
    print(r.__saldo)
except AttributeError:
    print("AttributeError: __saldo tidak bisa diakses dari luar")
Output
100000
AttributeError: __saldo tidak bisa diakses dari luar

3Getter, setter, dan @property

Cara klasik mengontrol akses adalah method getter/setter. Python punya cara yang lebih rapi: @property. Dari luar terlihat seperti atribut biasa, tetapi di dalamnya validasi tetap berjalan.

Contoh
class Rekening:
    def __init__(self, saldo):
        self._saldo = 0
        self.saldo = saldo          # lewat setter -> tervalidasi

    @property
    def saldo(self):                # getter
        return self._saldo

    @saldo.setter
    def saldo(self, nilai):         # setter
        if nilai < 0:
            raise ValueError("saldo tidak boleh negatif")
        self._saldo = nilai

r = Rekening(50000)
r.saldo = 75000
print(r.saldo)

try:
    r.saldo = -10
except ValueError as e:
    print("Ditolak:", e)
print(r.saldo)
Output
75000
Ditolak: saldo tidak boleh negatif
75000

Property tanpa setter bersifat baca-saja. Property juga bisa berupa nilai turunan yang dihitung setiap kali dibaca.

Contoh
class Persegi:
    def __init__(self, sisi):
        self._sisi = sisi

    @property
    def luas(self):              # dihitung, tidak disimpan
        return self._sisi ** 2

p = Persegi(4)
print(p.luas)
try:
    p.luas = 100
except AttributeError:
    print("luas hanya bisa dibaca")
Output
16
luas hanya bisa dibaca

4Method yang bermakna, bukan sekadar setter

Encapsulation yang baik menyediakan operasi bermakna sesuai aturan bisnis, bukan setter untuk semua atribut. Rekening sebaiknya punya setor dan tarik, bukan set_saldo.

Contoh
class Rekening:
    def __init__(self, pemilik):
        self.pemilik = pemilik
        self._saldo = 0
        self._riwayat = []

    def setor(self, jumlah):
        if jumlah <= 0:
            raise ValueError("jumlah harus positif")
        self._saldo += jumlah
        self._riwayat.append(("setor", jumlah))

    def tarik(self, jumlah):
        if jumlah > self._saldo:
            raise ValueError("saldo tidak cukup")
        self._saldo -= jumlah
        self._riwayat.append(("tarik", jumlah))

    @property
    def saldo(self):
        return self._saldo

r = Rekening("Sari")
r.setor(100000)
r.tarik(30000)
print(r.saldo, len(r._riwayat), "transaksi")
Output
70000 2 transaksi

Dengan cara ini, setiap perubahan saldo otomatis tercatat di riwayat. Aturan itu tidak mungkin terlewat karena kode luar tidak pernah mengubah _saldo secara langsung.

5Manfaat encapsulation

  • Data selalu valid — validasi berada di satu tempat.
  • Bebas mengubah implementasi — cara penyimpanan internal boleh diganti selama method publiknya tetap.
  • Lebih mudah di-debug — kalau saldo salah, cukup periksa method di class Rekening.
  • Antarmuka sederhana — pemakai class cukup tahu setor, tarik, dan saldo.

!Kesalahan umum

Membuat getter dan setter untuk setiap atribut tanpa validasi.

Itu sama saja dengan atribut publik. Sediakan hanya operasi yang memang dibutuhkan.

Mengira __saldo benar-benar mustahil diakses.

Masih bisa lewat _Rekening__saldo. Encapsulation di Python adalah kesepakatan, bukan pengamanan.

Di setter, menulis self.saldo = nilai (nama sama dengan property).

Setter memanggil dirinya sendiri tanpa henti (RecursionError). Simpan ke self._saldo.

Mengubah _atribut milik objek lain dari luar class.

Garis bawah adalah tanda "jangan disentuh". Pakai method publik yang disediakan.

≡Istilah penting

Encapsulation
Menyatukan data dan method serta membatasi akses langsung ke data.
Invarian
Aturan yang harus selalu benar pada objek (misal saldo ≥ 0).
Getter / setter
Method untuk membaca / mengubah atribut secara terkontrol.
@property
Decorator yang membuat method bisa diakses seperti atribut.
Name mangling
Pengubahan otomatis __nama menjadi _Class__nama.

Ringkasan & simulasi

Konsep kunci

  • __nama memicu name mangling menjadi _Class__nama — bukan rahasia mutlak, tapi penanda keras.
  • _nama (satu garis bawah) hanya konvensi: "jangan sentuh dari luar".
  • @property memberi akses baca; @x.setter menambahkan validasi saat menulis.
  • Tujuan utamanya: state object tidak bisa masuk kondisi tidak valid.
Analogi

ATM. Kamu tidak menyentuh lempengan database bank langsung — kamu menekan tombol, sistem memvalidasi, baru saldo berubah.

Kode contoh

class Rekening:
    def __init__(self, saldo_awal):
        self.__saldo = saldo_awal        # privat

    @property
    def saldo(self):                     # getter
        return self.__saldo

    @saldo.setter
    def saldo(self, nilai):              # setter + validasi
        if nilai < 0:
            raise ValueError("Saldo tidak boleh negatif")
        self.__saldo = nilai

r = Rekening(500000)
r.saldo = 750000        # lewat setter, divalidasi
print(r.saldo)          # 750000

r.saldo = -1            # ValueError

Panel simulasi

Kode di atas dijalankan sungguhan. State objek direkam tiap langkah.

Mau mencoba sendiri? Buka Playground Python →

Sudah paham Encapsulation?

5 soal pilihan ganda, langsung dinilai beserta pembahasannya.

Kerjakan latihan →