Pemrograman Berorientasi Objek · 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.
class Rekening:
def __init__(self, saldo):
self.saldo = saldo
r = Rekening(100000)
r.saldo = -999999 # tidak ada yang menghalangi
print(r.saldo)
-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:
| Penulisan | Sifat | Artinya |
|---|---|---|
saldo | Publik | Bebas dipakai dari mana saja. |
_saldo | Protected (konvensi) | "Urusan internal, jangan disentuh dari luar." Tetap bisa diakses. |
__saldo | Private (name mangling) | Nama diubah otomatis menjadi _NamaClass__saldo sehingga sulit diakses tak sengaja. |
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")
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.
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)
75000 Ditolak: saldo tidak boleh negatif 75000
Property tanpa setter bersifat baca-saja. Property juga bisa berupa nilai turunan yang dihitung setiap kali dibaca.
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")
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.
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")
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, dansaldo.
!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
__namamenjadi_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.
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. Isi objek direkam tiap langkah.
Output
Mau mencoba sendiri? Buka Playground Python →
Sudah paham Encapsulation?
5 soal pilihan ganda, langsung dinilai beserta pembahasannya.