Pemrograman Berorientasi Objek · Topik 05 dari 6
Polymorphism
Satu perintah, banyak bentuk
Polymorphism memungkinkan satu nama method dipanggil pada objek berbeda, dan tiap objek merespons sesuai tipenya sendiri. Pemanggil tidak perlu tahu tipe pastinya.
Polymorphism berarti "banyak bentuk". Dalam PBO, artinya satu perintah yang sama bisa menghasilkan perilaku berbeda tergantung objek yang menerimanya. Pemanggil cukup tahu apa yang diminta, tanpa perlu tahu jenis objeknya.
1Polymorphism lewat override
Bentuk yang paling umum: beberapa subclass meng-override method yang sama dari parent. Kode pemanggil memperlakukan semuanya dengan cara yang seragam.
class Bentuk:
def luas(self):
raise NotImplementedError
class Persegi(Bentuk):
def __init__(self, s):
self.s = s
def luas(self):
return self.s ** 2
class Lingkaran(Bentuk):
def __init__(self, r):
self.r = r
def luas(self):
return round(3.14 * self.r ** 2, 2)
for b in [Persegi(4), Lingkaran(10)]:
print(type(b).__name__, b.luas())
Persegi 16 Lingkaran 314.0
Perulangan di atas tidak memeriksa jenis objek sama sekali. Menambah bentuk baru (misal Segitiga) tidak memerlukan perubahan pada perulangan.
2Menggantikan rantai if-isinstance
Tanpa polymorphism, kode cenderung penuh percabangan berdasarkan tipe. Setiap jenis baru berarti mengubah fungsi ini lagi.
# Tanpa polymorphism (hindari)
def suara(hewan):
if hewan == "kucing":
return "Meong"
elif hewan == "anjing":
return "Guk"
return "?"
# Dengan polymorphism
class Kucing:
def suara(self): return "Meong"
class Anjing:
def suara(self): return "Guk"
print(suara("anjing"))
print([h.suara() for h in (Kucing(), Anjing())])
Guk ['Meong', 'Guk']
3Duck typing
Python tidak mewajibkan objek berasal dari parent yang sama. Selama objek punya method yang dibutuhkan, ia bisa dipakai. "Jika berjalan seperti bebek dan bersuara seperti bebek, anggap saja bebek."
class Bebek:
def bersuara(self): return "Kwek"
class Robot: # tidak ada hubungan dengan Bebek
def bersuara(self): return "Bip-bip"
def bunyikan(x):
return x.bersuara() # yang penting punya bersuara()
print(bunyikan(Bebek()), bunyikan(Robot()))
Kwek Bip-bip
4Operator overloading dengan dunder
Operator seperti +, ==, dan fungsi len() juga polimorfik. Definisikan method khusus (dunder) agar class buatanmu ikut mendukungnya.
class Vektor:
def __init__(self, x, y):
self.x, self.y = x, y
def __add__(self, lain): # operator +
return Vektor(self.x + lain.x, self.y + lain.y)
def __eq__(self, lain): # operator ==
return (self.x, self.y) == (lain.x, lain.y)
def __str__(self):
return f"Vektor({self.x}, {self.y})"
v = Vektor(1, 2) + Vektor(3, 4)
print(v)
print(v == Vektor(4, 6))
Vektor(4, 6) True
| Method | Dipanggil oleh |
|---|---|
__add__ | a + b |
__eq__ | a == b |
__lt__ | a < b (dan sorted()) |
__len__ | len(a) |
__str__ | print(a), str(a) |
5Bagaimana dengan method overloading?
Di Java, satu method boleh didefinisikan berkali-kali dengan parameter berbeda. Di Python, definisi kedua menimpa yang pertama. Gantinya, gunakan parameter bawaan atau *args.
class Kalkulator:
def jumlah(self, *angka):
return sum(angka)
k = Kalkulator()
print(k.jumlah(1, 2))
print(k.jumlah(1, 2, 3, 4))
3 10
!Kesalahan umum
Mengecek tipe dengan if type(x) == ... di mana-mana.
Pindahkan perilaku ke method masing-masing class dan panggil secara seragam.
Override dengan nama method yang sedikit berbeda (hitung_luas vs luas).
Polymorphism hanya bekerja jika nama dan parameternya sama persis.
Mendefinisikan dua method bernama sama dengan parameter berbeda.
Python hanya menyimpan yang terakhir. Gunakan parameter bawaan atau *args.
__eq__ mengembalikan teks atau angka.
Kembalikan True/False agar perbandingan bekerja seperti seharusnya.
≡Istilah penting
- Polymorphism
- Satu antarmuka, banyak implementasi.
- Duck typing
- Kecocokan ditentukan oleh method yang dimiliki, bukan oleh tipe.
- Dunder method
- Method berawalan dan berakhiran
__, misal__add__. - Operator overloading
- Memberi arti operator (
+,==) untuk class sendiri. - Open/closed principle
- Mudah ditambah fitur baru tanpa mengubah kode lama.
Ringkasan & simulasi
Konsep kunci
- Method overriding adalah bentuk polymorphism paling umum di PBO.
- Python memilih implementasi saat runtime berdasarkan tipe objek.
- Duck typing: selama objek punya method yang dipanggil, ia sah — tak perlu satu induk.
- Kode jadi terbuka untuk tipe baru tanpa mengubah loop pemanggil.
Tombol "print" di keyboard. Yang terjadi berbeda tergantung aplikasi yang aktif — perintahnya satu, hasilnya menyesuaikan objek penerima.
Kode contoh
class Persegi:
def __init__(self, s): self.s = s
def luas(self): return self.s ** 2
class Lingkaran:
def __init__(self, r): self.r = r
def luas(self): return round(3.14159 * self.r ** 2, 2)
class Segitiga:
def __init__(self, a, t): self.a, self.t = a, t
def luas(self): return 0.5 * self.a * self.t
for bentuk in [Persegi(4), Lingkaran(7), Segitiga(6, 8)]:
print(bentuk.luas()) # 16, 153.94, 24.0
# satu loop, tiga perilaku berbeda
Panel simulasi
Kode di atas dijalankan sungguhan. Isi objek direkam tiap langkah.
Output
Mau mencoba sendiri? Buka Playground Python →
Sudah paham Polymorphism?
5 soal pilihan ganda, langsung dinilai beserta pembahasannya.