Polimorfisme dalam Python

Polimorfisme merupakan salah satu konsep penting dalam pemrograman berorientasi objek Python. Istilah polimorfisme mengacu pada kemampuan berbagai objek untuk merespons pemanggilan metode yang sama dengan perilaku yang dapat berbeda.

Sebelum lebih lanjut mempelajari materi tentang Polimorfisme dalam Python, terlebih dahulu pelajari materi tentang: Class dalam Python, Inheritance atau Pewarisan dalam Python, dan Multiple Inheritance dalam Python.

Konsep polimorfisme membuat program lebih fleksibel karena satu nama metode dapat digunakan oleh berbagai objek. Setiap class dapat memberikan pelaksanaan metode sesuai karakteristik objek tersebut. Sebagai contoh, terdapat beberapa jenis hewan yang memiliki metode `suara()`. Kucing dapat menghasilkan suara "Meong", sedangkan anjing dapat menghasilkan suara "Guk guk". Nama metode yang digunakan tetap sama, tetapi perilakunya berbeda.

Pengertian Polimorfisme

Polimorfisme berasal dari gabungan kata yang bermakna banyak bentuk. Dalam Python, polimorfisme dapat digunakan ketika beberapa objek memiliki metode dengan nama yang sama, tetapi setiap objek memberikan hasil atau perilaku yang berbeda.

Contoh sederhana:
class Kucing:
 def suara(self):
  print("Meong")

class Anjing:
 def suara(self):
  print("Guk guk")

Kedua class memiliki metode `suara()`. Namun, hasil pemanggilannya berbeda:
kucing = Kucing()
anjing = Anjing()
kucing.suara()
anjing.suara()

Hasil:
Meong
Guk guk

Tujuan Polimorfisme

Polimorfisme dapat digunakan untuk:

• Membuat program lebih fleksibel.
• Menggunakan nama metode yang sama untuk objek berbeda.
• Mengurangi ketergantungan terhadap jenis class tertentu.
• Mempermudah pengembangan program.
• Membuat kode lebih mudah digunakan kembali.
• Menyederhanakan pengolahan berbagai jenis objek.

Polimorfisme melalui Method Overriding

Salah satu bentuk polimorfisme yang sering digunakan dalam Python adalah method overriding. Method overriding terjadi ketika child class memiliki metode dengan nama yang sama seperti parent class.

Contoh:
class Hewan:
 def suara(self):
  print("Hewan mengeluarkan suara")

class Kucing(Hewan):
 def suara(self):
  print("Meong")

class Anjing(Hewan):
 def suara(self):
  print("Guk guk")

Ketiga class tersebut memiliki metode `suara()`. Namun, `Kucing` dan `Anjing` memberikan perilaku yang berbeda.

Menggunakan Polimorfisme dengan Perulangan

Polimorfisme menjadi lebih berguna ketika beberapa objek disimpan dalam satu list.
class Kucing:
 def suara(self):
  print("Meong")

class Anjing:
 def suara(self):
  print("Guk guk")

class Sapi:
 def suara(self):
  print("Moo")

hewan = [Kucing(), Anjing(), Sapi()]
for objek in hewan:
objek.suara()

Hasil:
Meong
Guk guk
Moo

Perulangan tidak perlu mengetahui jenis class setiap objek. Perulangan cukup memanggil metode `suara()`.

Duck Typing dalam Python

Python dikenal memiliki pendekatan yang sering disebut duck typing. Dalam pendekatan ini, jenis objek tidak selalu menjadi hal utama. Yang lebih penting adalah kemampuan objek untuk menyediakan operasi atau metode yang diperlukan.

Contoh:
class Kucing:
 def suara(self):
  print("Meong")

class Anjing:
 def suara(self):
  print("Guk guk")

def buat_suara(hewan):
hewan.suara()

Fungsi `buat_suara()` dapat menerima objek dari kedua class tersebut:
kucing = Kucing()
anjing = Anjing()
buat_suara(kucing)
buat_suara(anjing)

Hasil:
Meong
Guk guk

Fungsi tersebut tidak perlu mengetahui apakah objek yang diterima merupakan `Kucing` atau `Anjing`. Selama objek memiliki metode `suara()`, metode tersebut dapat dipanggil.

Polimorfisme dengan Fungsi

Polimorfisme dapat diterapkan melalui fungsi yang menerima objek.

Contoh:
class Mobil:
 def bergerak(self):
  print("Mobil bergerak")

class Kapal:
 def bergerak(self):
  print("Kapal bergerak")

def jalankan(kendaraan):
kendaraan.bergerak()

Penggunaan:
mobil = Mobil()
kapal = Kapal()
jalankan(mobil)
jalankan(kapal)

Hasil:
Mobil bergerak
Kapal bergerak

Fungsi `jalankan()` dapat digunakan untuk berbagai objek yang memiliki metode `bergerak()`.

Polimorfisme melalui Inheritance

Polimorfisme juga dapat digunakan bersama inheritance.

Contoh:
class Hewan:
 def suara(self):
  print("Suara hewan")

class Kucing(Hewan):
 def suara(self):
  print("Meong")

class Anjing(Hewan):
 def suara(self):
  print("Guk guk")

Kemudian:
hewan1 = Kucing()
hewan2 = Anjing()
hewan1.suara()
hewan2.suara()

Meskipun kedua objek berasal dari turunan class yang sama, masing-masing memiliki perilaku metode yang berbeda.

Contoh Polimorfisme pada Kendaraan

Misalnya terdapat beberapa kendaraan.
class Mobil:
 def bergerak(self):
  print("Mobil berjalan di jalan")

class Kapal:
 def bergerak(self):
  print("Kapal bergerak di air")

class Pesawat:
 def bergerak(self):
  print("Pesawat bergerak di udara")

Ketiganya memiliki metode yang sama:
bergerak()

Namun perilakunya berbeda. Objek dapat diproses dengan satu perulangan:
kendaraan = [Mobil(), Kapal(), Pesawat()]
for objek in kendaraan:
objek.bergerak()

Hasil:
Mobil berjalan di jalan
Kapal bergerak di air
Pesawat bergerak di udara

Polimorfisme dengan Fungsi Bawaan Python

Beberapa fungsi bawaan Python dapat digunakan terhadap berbagai jenis objek. Contohnya adalah `len()`.
print(len("Python"))
print(len([10, 20, 30]))
print(len((1, 2, 3, 4)))

Fungsi yang sama digunakan pada jenis data berbeda.

Hasilnya:
6
3
4

Fungsi `len()` dapat bekerja karena berbagai objek menyediakan perilaku yang sesuai untuk operasi tersebut.

Polimorfisme pada Operator

Polimorfisme juga dapat ditemukan pada operator Python. Operator `+` dapat digunakan untuk berbagai jenis data.

Contoh bilangan:
print(10 + 20)

Hasil:
30

Operator yang sama juga dapat digunakan untuk teks:
print("Halo " + "Python")

Hasil:
Halo Python

Pada bilangan, `+` digunakan untuk penjumlahan. Pada teks, `+` digunakan untuk menggabungkan teks.

Operator dengan Objek

Perilaku operator juga dapat diatur melalui metode khusus.

Contoh:
class Titik:
 def __init__(self, x, y):
  self.x = x
  self.y = y

 def __add__(self, titik):
  return Titik(self.x + titik.x, self.y + titik.y)

Penggunaan:
titik1 = Titik(2, 3)
titik2 = Titik(4, 5)
hasil = titik1 + titik2
print(hasil.x)
print(hasil.y)

Hasil:
6
8

Pada contoh tersebut, perilaku operator `+` ditentukan melalui metode khusus `__add__()`.

Polimorfisme dan Method yang Sama

Contoh lain dapat dibuat menggunakan class bangun datar.
class Persegi:
 def luas(self):
  return 10 * 10

class PersegiPanjang:
 def luas(self):
  return 10 * 5

Kedua class memiliki metode `luas()`. Objek dapat diproses dengan cara yang sama:
bangun = [Persegi(), PersegiPanjang()]
for objek in bangun:
print(objek.luas())

Hasil:
100
50

Polimorfisme dengan Parameter

Metode yang sama dapat menerima data berbeda.

Contoh:
class Siswa:
 def tampilkan(self):
  print("Data siswa")

class Guru:
 def tampilkan(self):
  print("Data guru")

def tampilkan_data(objek):
 objek.tampilkan()

Penggunaan:
siswa = Siswa()
guru = Guru()
tampilkan_data(siswa)
tampilkan_data(guru)

Hasil:
Data siswa
Data guru

Polimorfisme dengan Class Dasar

Class dasar dapat digunakan untuk menentukan metode yang harus tersedia pada class turunan.

Contoh:
class Hewan:
 def suara(self):
  pass

class Kucing(Hewan):
 def suara(self):
  print("Meong")

class Anjing(Hewan):
 def suara(self):
  print("Guk guk")

Setiap class turunan memiliki pelaksanaan metode `suara()` sendiri.

Polimorfisme dengan Abstract Base Class

Python menyediakan modul `abc` untuk membuat abstract base class.

Contoh:
from abc import ABC, abstractmethod
class Hewan(ABC):
 @abstractmethod
  def suara(self):
   pass

Class turunan harus menyediakan metode `suara()`.
class Kucing(Hewan):
 def suara(self):
  print("Meong")

Pendekatan tersebut berguna ketika rancangan program membutuhkan aturan yang lebih jelas mengenai metode yang harus tersedia pada class turunan.

Polimorfisme dan Abstraksi

Polimorfisme sering digunakan bersama abstraksi. Abstraksi berfokus pada bagian penting yang perlu tersedia, sedangkan class turunan menentukan cara pelaksanaannya.

Contoh:
Hewan
 |
 +-- suara()
     |
     +-- Kucing → Meong
     +-- Anjing → Guk guk
     +-- Sapi → Moo

Nama metode tetap `suara()`, tetapi perilakunya dapat berbeda.

Perbedaan Method Overriding dan Polimorfisme

Method overriding merupakan teknik ketika child class mengganti metode dari parent class. Polimorfisme merupakan kemampuan menggunakan antarmuka atau nama metode yang sama untuk berbagai objek dengan perilaku yang dapat berbeda.

Contoh method overriding:
class Hewan:
 def suara(self):
  print("Suara hewan")

class Kucing(Hewan):
 def suara(self):
  print("Meong")

Ketika beberapa objek digunakan melalui metode yang sama, muncul perilaku polimorfisme:
hewan = [Kucing(), Anjing(), Sapi()]
for objek in hewan:
objek.suara()

Perbedaan Inheritance dan Polimorfisme

Konsep	Fungsi
Inheritance	Membuat class memperoleh atribut dan metode dari class lain
Polimorfisme	Memungkinkan objek berbeda merespons metode yang sama dengan perilaku berbeda
Method overriding	Mengganti pelaksanaan metode parent class
Duck typing	Mengutamakan kemampuan objek untuk melakukan operasi tertentu

Contoh Program Polimorfisme Lengkap

Berikut diberikan contoh program polimorfisme secara lengkap.
class Hewan:
 def suara(self):
  print("Hewan mengeluarkan suara")

class Kucing(Hewan):
 def suara(self):
  print("Meong")

class Anjing(Hewan):
 def suara(self):
  print("Guk guk")

class Sapi(Hewan):
 def suara(self):
  print("Moo")

daftar_hewan = 

[
Kucing(),
Anjing(),
Sapi()

]

for hewan in daftar_hewan:
hewan.suara()

Hasil:
Meong
Guk guk
Moo

Kode tersebut menunjukkan bentuk sederhana polimorfisme. Perulangan menggunakan nama metode yang sama, yaitu `suara()`, tetapi hasilnya bergantung pada jenis objek.

Contoh Polimorfisme pada Bangun Datar

Berikut diberikan contoh polimorfisme pada bangun datar.
class Persegi:
 def __init__(self, sisi):
  self.sisi = sisi
 def luas(self):
  return self.sisi * self.sisi

class PersegiPanjang:
 def __init__(self, panjang, lebar):
  self.panjang = panjang
  self.lebar = lebar
 def luas(self):
  return self.panjang * self.lebar

bangun1 = Persegi(5)
bangun2 = PersegiPanjang(10, 4)

daftar_bangun = [bangun1, bangun2]

for bangun in daftar_bangun:
print(bangun.luas())

Hasil:
25
40

Meskipun kedua objek berasal dari class berbeda, keduanya memiliki metode `luas()`.

Contoh Polimorfisme pada Pembayaran

Konsep polimorfisme juga dapat digunakan pada program pembayaran.
class Tunai:
 def bayar(self, jumlah):
  print("Membayar tunai:", jumlah)

class Transfer:
 def bayar(self, jumlah):
  print("Membayar melalui transfer:", jumlah)

class DompetDigital:
 def bayar(self, jumlah):
  print("Membayar melalui dompet digital:", jumlah)

Kemudian:
metode = 

[
Tunai(),
Transfer(),
DompetDigital()
]

for cara in metode:
cara.bayar(50000)

Hasil:
Membayar tunai: 50000
Membayar melalui transfer: 50000
Membayar melalui dompet digital: 50000

Metode `bayar()` memiliki nama yang sama pada setiap class, tetapi pelaksanaannya berbeda.

Keuntungan Polimorfisme

Polimorfisme memberikan beberapa keuntungan dalam pengembangan program:

• Kode menjadi lebih fleksibel.
• Satu fungsi dapat digunakan untuk berbagai jenis objek.
• Program lebih mudah dikembangkan.
• Pengulangan kode dapat dikurangi.
• Hubungan antarclass dapat dibuat lebih teratur.
• Perubahan pada satu class tidak selalu memerlukan perubahan pada bagian program yang memanggil metode.

Kekurangan Polimorfisme

Polimorfisme juga perlu digunakan dengan pemahaman yang baik. Beberapa hal yang perlu diperhatikan:

• Perilaku metode dapat berbeda sehingga perlu dipahami oleh pembuat program.
• Struktur class yang terlalu kompleks dapat menyulitkan pemeliharaan.
• Kesalahan nama metode dapat menyebabkan kesalahan saat program dijalankan.
• Penggunaan pewarisan yang berlebihan dapat membuat hubungan class sulit dipahami.

Waktu Penggunaan Polimorfisme

Polimorfisme cocok digunakan ketika beberapa objek memiliki operasi yang sama tetapi cara pelaksanaannya berbeda.

Contoh:

• Berbagai jenis hewan memiliki metode `suara()`.
• Berbagai kendaraan memiliki metode `bergerak()`.
• Berbagai bangun datar memiliki metode `luas()`.
• Berbagai metode pembayaran memiliki metode `bayar()`.
• Berbagai jenis pengguna memiliki metode `tampilkan_data()`.

Pola tersebut membuat kode utama tidak perlu terlalu bergantung pada jenis objek tertentu.

Langkah Memahami Polimorfisme

Untuk mempelajari polimorfisme, beberapa langkah berikut dapat dilakukan:

1. Pahami terlebih dahulu class dan objek.
2. Pelajari inheritance.
3. Pahami metode dan atribut.
4. Pelajari method overriding.
5. Buat beberapa class dengan nama metode yang sama.
6. Buat objek dari setiap class.
7. Simpan objek dalam list.
8. Gunakan perulangan untuk memanggil metode yang sama.
9. Pelajari duck typing.
10. Pelajari penggunaan abstract base class jika diperlukan.

Latihan

Berikut diberikan beberapa latihan yang dapat langsung dipraktikkan oleh pengguna.

Latihan 1

Buat tiga class:
Kucing
Anjing
Sapi

Setiap class memiliki metode `suara()` dengan hasil berbeda.

Latihan 2

Buat beberapa class kendaraan yang memiliki metode `bergerak()`.

Latihan 3

Buat class `Persegi` dan `Lingkaran`. Keduanya harus memiliki metode `luas()`.

Latihan 4

Simpan objek beberapa bangun datar ke dalam list. Gunakan perulangan untuk memanggil metode `luas()`.

Latihan 5

Buat class `Tunai`, `Transfer`, dan `DompetDigital`. Setiap class memiliki metode `bayar()`.

Latihan 6

Buat fungsi yang menerima objek sebagai parameter dan memanggil metode yang sama dari setiap objek.

Latihan 7

Buat program menggunakan inheritance dan method overriding untuk menunjukkan polimorfisme.

Latihan 8

Gunakan modul `abc` untuk membuat abstract base class dengan metode abstrak.

Kesimpulan

Polimorfisme merupakan konsep pemrograman berorientasi objek yang memungkinkan berbagai objek menggunakan metode dengan nama yang sama tetapi memberikan perilaku berbeda. Konsep ini membuat program lebih fleksibel karena kode yang sama dapat digunakan untuk mengolah berbagai jenis objek.

Salah satu penerapan yang umum adalah method overriding. Child class dapat mengganti metode yang diwarisi dari parent class sesuai kebutuhan. Ketika beberapa objek dari class berbeda diproses menggunakan metode yang sama, perilaku polimorfisme dapat terlihat dengan jelas.

Python juga mendukung pendekatan duck typing. Dalam pendekatan tersebut, kemampuan objek menjadi hal penting. Selama objek menyediakan metode yang dibutuhkan, objek tersebut dapat digunakan oleh fungsi tertentu tanpa harus memeriksa jenis class secara khusus.

Polimorfisme juga dapat ditemukan pada fungsi bawaan, operator, inheritance, dan abstract base class. Dengan memahami konsep tersebut, program Python dapat dibuat lebih terstruktur, fleksibel, dan mudah dikembangkan.

Pemahaman polimorfisme sebaiknya dibangun setelah memahami class, objek, metode, dan inheritance. Setelah konsep dasar tersebut dikuasai, penerapan polimorfisme melalui berbagai contoh program akan menjadi lebih mudah dipahami.

Artikel ini akan dibaca oleh: Fadiya Hanun Lailatul Arsy, Fadlan Wahyu Saputra, Fahra Amelia, Fajar Rizky Saputra, dan Farah Husna Pramesti.

Location: Kota Semarang, Jawa Tengah, Indonesia

Berbagi :