PBO Belajar PythonDasar Python & PBO · simulasi interaktif

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.

Contoh
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())
Output
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.

Contoh
# 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())])
Output
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."

Contoh
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()))
Output
Kwek Bip-bip

4Operator overloading dengan dunder

Operator seperti +, ==, dan fungsi len() juga polimorfik. Definisikan method khusus (dunder) agar class buatanmu ikut mendukungnya.

Contoh
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))
Output
Vektor(4, 6)
True
MethodDipanggil 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.

Contoh
class Kalkulator:
    def jumlah(self, *angka):
        return sum(angka)

k = Kalkulator()
print(k.jumlah(1, 2))
print(k.jumlah(1, 2, 3, 4))
Output
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.
Analogi

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.

Mau mencoba sendiri? Buka Playground Python →

Sudah paham Polymorphism?

5 soal pilihan ganda, langsung dinilai beserta pembahasannya.

Kerjakan latihan →