Pemrograman Berorientasi Objek (OOP) adalah paradigma pemrograman yang mendasarkan struktur program pada konsep objek. Dalam Python, OOP sangat fundamental dan memungkinkan pengembang untuk membuat kode yang lebih modular, mudah dipelihara, dan dapat digunakan kembali. Konsep inti OOP meliputi Enkapsulasi, Pewarisan (Inheritance), Abstraksi, dan Polimorfisme.
Kelas adalah cetak biru (blueprint) untuk membuat objek, sedangkan objek adalah instansi nyata dari kelas tersebut. Mari kita lihat contoh sederhana menggunakan kelas `Hewan`.
class Hewan:
# Konstruktor (__init__)
def __init__(self, nama, spesies):
self.nama = nama
self.spesies = spesies
self.status_lapar = True
# Metode (Method)
def bersuara(self, suara):
print(f"{self.nama} ({self.spesies}) berkata: {suara}!")
def makan(self):
if self.status_lapar:
self.status_lapar = False
print(f"{self.nama} sedang makan.")
else:
print(f"{self.nama} sudah kenyang.")
# Membuat Objek (Instansiasi)
anjing_saya = Hewan("Buddy", "Canis familiaris")
kucing_saya = Hewan("Milo", "Felis catus")
# Memanggil Metode
anjing_saya.bersuara("Guk guk!")
kucing_saya.makan()
anjing_saya.makan()
Pewarisan memungkinkan kelas baru (subclass/child class) mewarisi atribut dan metode dari kelas yang sudah ada (superclass/parent class). Ini sangat membantu dalam menghindari duplikasi kode.
Kita akan membuat subkelas dari `Hewan` yaitu `Anjing` dan `Kucing` yang memiliki perilaku spesifik.
# Kelas Induk (Parent Class) sudah didefinisikan di atas
# Kelas Anak (Child Class)
class Anjing(Hewan):
def __init__(self, nama, ras):
# Memanggil konstruktor parent class
super().__init__(nama, "Anjing")
self.ras = ras
# Overriding method bersuara
def bersuara(self, suara="Guk Guk"):
print(f"{self.nama} ({self.ras}) menggonggong keras!")
def bermain_lempar_tangkap(self):
print(f"{self.nama} sedang asyik bermain lempar tangkap.")
# Instansiasi kelas anak
herder = Anjing("Max", "German Shepherd")
herder.bersuara() # Menggunakan method yang di-override
herder.makan() # Menggunakan method dari parent class
herder.bermain_lempar_tangkap()
Enkapsulasi adalah membungkus data (atribut) dan metode yang beroperasi pada data tersebut ke dalam satu unit (kelas), serta menyembunyikan detail internal implementasi. Di Python, kita menggunakan konvensi dengan awalan underscore tunggal (`_`) untuk menandakan atribut yang seharusnya bersifat 'protected' (meskipun Python tidak sepenuhnya memberlakukan akses private seperti Java atau C++).
Abstraksi berfokus pada menampilkan hanya fungsionalitas penting kepada pengguna dan menyembunyikan kompleksitas di baliknya. Dalam contoh di atas, ketika kita memanggil `herder.makan()`, kita tidak perlu tahu secara detail bagaimana logika `self.status_lapar` diubah; kita hanya peduli hasilnya.
class RekeningBank:
def __init__(self, saldo_awal):
# Atribut protected (konvensi)
self._saldo = saldo_awal
def deposit(self, jumlah):
if jumlah > 0:
self._saldo += jumlah
print(f"Deposit berhasil. Saldo baru: {self._saldo}")
else:
print("Jumlah deposit harus positif.")
def cek_saldo(self):
# Metode publik untuk melihat saldo
print(f"Saldo Anda saat ini adalah: {self._saldo}")
rekening_andi = RekeningBank(1000000)
rekening_andi.cek_saldo()
rekening_andi.deposit(50000)
# Meskipun tidak disarankan, Python mengizinkan akses langsung:
# rekening_andi._saldo = -500000
# Hal ini menekankan bahwa OOP Python mengandalkan disiplin programmer.
Dengan memahami dan menerapkan struktur OOP di Python, pembuatan aplikasi yang kompleks menjadi jauh lebih terstruktur. Konsep-konsep ini adalah fondasi penting bagi siapa pun yang ingin menulis kode Python yang efisien dan skalabel.