Dalam object oriented programming (OOP), inheritance atau pewarisan adalah salah satu konsep penting yang memungkinkan kita untuk mengorganisir dan membangun hierarki class. Seperti halnya bahasa pemrograman lain yang mendukung OOP, di dalam Python pun juga memungkinkan kita untuk menerapkan inheritance ini. Melalui inheritance, kita dapat membuat class baru yang mewarisi atribut dan method dari class yang sudah ada, serta memperluas fungsionalitas dengan menambahkan atau mengubah perilaku/method dari class yang baru (overriding).
Artikel ini akan menjelaskan konsep dasar inheritance di Python dan bagaimana mengimplementasikannya.
Pengenalan Inheritance
Inheritance adalah konsep dalam pemrograman berorientasi objek di mana sebuah class baru dapat mewarisi atribut dan method dari class yang sudah ada. Class yang mewarisi disebut kelas induk atau superclass atau parent class, sementara class yang menerima warisan disebut kelas anak atau subclass atau child class. Dengan inheritance, kita dapat mengorganisir kode secara hierarkis, memanfaatkan kembali kode yang sudah ada, dan memperluas fungsionalitas dengan menambahkan atau mengubah methodnya.
Mengapa perlu Inheritance?
Inheritance (pewarisan) dalam OOP dibutuhkan untuk mengurangi duplikasi kode, meningkatkan keteraturan, dan mempermudah proses pengembangan dan pemeliharaan kode. Dalam pengembangan perangkat lunak yang kompleks, sering kali terdapat beberapa class yang memiliki karakteristik dan perilaku yang mirip. Jika semua perilaku tersebut dituliskan secara terpisah dalam setiap class, maka akan terjadi redundansi kode yang menyebabkan kode sulit dipelihara dan perubahan menjadi lebih rumit.
Dengan inheritance, kita dapat membuat kelas induk (superclass) yang mendefinisikan perilaku umum, kemudian class anak (subclass) yang dapat mewarisi sifat dari superclass tersebut tanpa perlu menuliskannya ulang. Ini memungkinkan kode menjadi lebih modular, fleksibel, dan mudah diperluas. Inheritance juga memungkinkan pengembang untuk menambahkan atau memodifikasi perilaku tertentu pada subclass tanpa mempengaruhi struktur dasar yang sudah ada di superclass.
Perhatikan contoh sederhana berikut ini
class Kambing:
def __init__(self, nama, umur):
self.nama = nama
self.umur = umur
def bersuara(self):
return f"{self.nama} mengembek"
def get_info(self):
return f"{self.nama} usianya {self.umur} tahun"
class Kucing:
def __init__(self, nama, umur):
self.nama = nama
self.umur = umur
def bersuara(self):
return f"{self.nama} mengeong"
def get_info(self):
return f"{self.nama} usianya {self.umur} tahun"
kambing = Kambing("Dolly", 3)
kucing = Kucing("Kitty", 2)
print(kambing.bersuara()) # Output: Dolly mengembek
print(kucing.bersuara()) # Output: Kitty mengeong
print(kambing.get_info()) # Output: Dolly usianya 3 tahun
print(kucing.get_info()) # Output: Kitty usianya 2 tahun
Dari contoh tersebut tampak bahwa struktur atribut nama dan umur serta method get_info() dan bersuara() muncul di kedua class (Kambing dan Kucing). Jika ada perubahan pada format atau isi get_info(), maka perubahan harus dilakukan di dua tempat. Selain itu, jika ingin menambahkan perilaku baru yang bersifat umum untuk semua hewan, maka kita harus memperbarui setiap class satu per satu.
Hal ini berisiko munculnya inkonsistensi tinggi karena modifikasi di satu class tidak otomatis tercermin di class lain.
Penerapan Inheritance
Dalam Python, inheritance diimplementasikan dengan menyebutkan nama superclass dalam pendefinisian subclassnya, tepatnya pada bagian parameter classnya. Berikut adalah contoh sederhana untuk mengilustrasikan penerapan inheritance:
# superclass
class Karyawan:
nik = ""
nama = ""
def gajiPokok(self):
return 3000000
def printData(self):
print("NIK: ", self.nik)
print("Nama: ", self.nama)
print("Gaji Pokok: ", self.gajiPokok())
# subclass Dosen mewarisi Karyawan
class Dosen(Karyawan):
nidn = ""
def tunjangan(self):
return 2000000
# overriding
def printData(self):
print("NIK: ", self.nik)
print("Nama: ", self.nama)
print("NIDN: ", self.nidn)
print("Gaji Pokok: ", self.gajiPokok())
print("Tunjangan: ", self.tunjangan())
Pada contoh di atas, kita memiliki class Karyawan sebagai superclass dan class Dosen sebagai subclass yang mewarisi dari class Karyawan. Class Karyawan memiliki beberapa atribut yaitu nik dan nama. Class ini juga memiliki method gajiPokok() yang menghasilkan nilai 3.000.000 sebagai gaji pokok karyawan.
Adapun class Dosen, yang merupakan subclass dari class Karyawan, secara otomatis akan mewarisi atribut dan method dari superclassnya. Dengan kata lain, class Dosen juga memiliki atribut nik dan nama serta method gajiPokok() secara implisit. Selain itu, class Dosen memiliki atribut tambahan sendiri, yaitu nidn, serta method tunjangan() yang merupakan tambahan fungsionalitas dari class Dosen.
Konsep inheritace di Python juga sama seperti bahasa pemrograman lain, di mana sebuah superclass bisa mewariskan ke beberapa subclass, dan sebuah subclass hanya boleh memiliki sebuah superclass.
Overriding Method
Salah satu keuntungan dari inheritance adalah kita dapat mengubah perilaku method yang diwarisi dari superclass nya. Proses ini disebut overriding. Perhatikan kembali contoh kode Python di atas. Implementasi method printData() pada class Dosen berbeda dengan superclassnya. Inilah contoh penerapan dari overriding.
Sekarang kita coba membuat beberapa obyek/instance dari kedua class di atas untuk melihat efek dari overriding ini. Pertama kita coba buat obyek karyawan1 dari class Karyawan.
karyawan1 = Karyawan()
karyawan1.nik = "K01"
karyawan1.nama = "Budi"
karyawan1.printData()
# output:
# NIK: K01
# Nama: Budi
# Gaji Pokok: 3000000
Selanjutnya kita buat pula obyek karyawan2 dari class Dosen
karyawan2 = Dosen()
karyawan2.nik = "K01"
karyawan2.nama = "Budi"
karyawan2.nidn = "123"
karyawan2.printData()
# output:
# NIK: K01
# Nama: Budi
# NIDN: 123
# Gaji Pokok: 3000000
# Tunjangan: 2000000
Apabila kita bandingkan output method printData() dari kedua obyek, maka akan nampak perbedaan. Inilah efek dari overriding tersebut.
Inheritance dengan Constructor
Contoh kode penerapan inheritance pada Python di atas, kebetulan tidak terdapat constructor di dalamnya. Bagaimana jika superclass nya terdapat constructor? Perhatikan contoh kode berikut ini, yang merupakan modifikasi dari class Karyawan.
# superclass
class Karyawan:
# constructor
def __init__(self, nik, nama):
self.nik = nik
self.nama = nama
def gajiPokok(self):
return 3000000
def printData(self):
print("NIK: ", self.nik)
print("Nama: ", self.nama)
print("Gaji Pokok: ", self.gajiPokok())
Constructor class Karyawan memiliki dua buah parameter, yaitu nik dan nama.
Sama seperti di bahasa pemrograman lainnya, untuk membuat subclass dari superclass yang memiliki constructor di Python, perlu dibuat juga constructor pada subclassnya. Di dalam constructor subclass, perlu dibuat perintah yang merujuk ke constructor superclassnya dengan memberikan perintah super().
class Dosen(Karyawan):
# constructor
def __init__(self, nik, nama, nidn):
# memanggil constructor superclass
super().__init__(nik, nama)
self.nidn = nidn
def tunjangan(self):
return 2000000
# overriding
def printData(self):
print("NIK: ", self.nik)
print("Nama: ", self.nama)
print("NIDN: ", self.nidn)
print("Gaji Pokok: ", self.gajiPokok())
print("Tunjangan: ", self.tunjangan())
Berikut ini adalah contoh pembuatan obyek (instansiasi) dari class Karyawan dan Dosen, serta pemanggilan method printData().
karyawan1 = Karyawan("K01", "Budi")
karyawan1.printData()
#output:
#NIK: K01
#Nama: Budi
#Gaji Pokok: 3000000
karyawan2 = Dosen("K01", "Budi", "123")
karyawan2.printData()
#output:
#NIK: K01
#Nama: Budi
#Gaji Pokok: 3000000
#Tunjangan: 2000000
Finalisasi Class
Finalisasi class diperlukan supaya sebuah class tidak bisa dibuat subclassnya lagi. Pada penerapan inheritance di Java terdapat cara melakukan hal ini yaitu dengan menambahkan keyword final pada classnya. Sekarang bagaimana dengan Python?
Di modul utama Python, tidak ada cara untuk melakukan finalisasi class. Namun, masih ada alternatif cara untuk melakukannya dengan menggunakan library atau package final-class (lihat di: https://pypi.org/project/final-class/)
Sebelum menggunakannya, terlebih dahulu harus diinstall dengan perintah:
pip install final_class
Kemudian untuk menggunakannya, gunakan annotation @final di depan classnya.
from final_class import final
@final
class A:
...
class B(A): # akan muncul error
...
Pada contoh di atas, keyword atau annotation @final diberikan pada class A. Akibatnya, apabila dibuat class B yang merupakan subclass dari A, maka akan dihasilkan error. Dalam hal ini class B yang merupakan subclass dari A tidak bisa dibuat.
Kesimpulan
Inheritance adalah konsep penting dalam object oriented programming yang memungkinkan kita untuk membuat class dengan mewarisi atribut dan method dari class yang sudah ada. Dengan inheritance, kita dapat mengorganisir dan memperluas fungsionalitas kode dengan lebih efisien. Dalam artikel ini, kita telah membahas pengenalan penerapan inheritance dalam Python, serta konsep overriding method. Dengan pemahaman yang baik tentang inheritance, kita dapat mengoptimalkan struktur kode dan meningkatkan efisiensi pengembangan aplikasi.
