Pemrograman Berorientasi Objek (OOP) menjadi salah satu pilar penting dalam pengembangan perangkat lunak modern. PHP, yang awalnya dikenal sebagai bahasa scripting untuk membangun website dinamis, kini telah berevolusi dengan dukungan penuh terhadap paradigma OOP. Salah satu fitur inti dalam OOP adalah inheritance atau pewarisan. Fitur ini memungkinkan sebuah class mewarisi properti dan method dari class lain, sehingga kode menjadi lebih efisien, terstruktur, dan mudah dikembangkan.
Artikel ini akan membahas secara mendalam bagaimana inheritance bekerja di PHP, manfaat yang ditawarkan, serta penerapannya dalam praktik sehari-hari.
Apa Itu Inheritance dalam PHP?
Inheritance dalam PHP memungkinkan kita membuat sebuah class baru dengan mewarisi fungsi dan properti dari class lain. Class yang diwarisi disebut parent class atau superclass, sedangkan class yang menerima warisan disebut child class atau subclass.
Contoh sederhananya bisa dilihat pada situasi nyata: kita memiliki class Kendaraan, lalu membuat class Mobil dan Motor. Daripada menulis ulang properti seperti merk dan tahun, class Mobil dan Motor cukup mewarisi dari class Kendaraan.
class Kendaraan {
public $merk;
public $tahun;
public function info() {
return "Merk: $this->merk, Tahun: $this->tahun";
}
}
class Mobil extends Kendaraan {
public $tipe;
public function infoMobil() {
return $this->info() . ", Tipe: $this->tipe";
}
}
Dengan pendekatan ini, kode menjadi lebih singkat dan fleksibel untuk dikembangkan.
Kenapa Inheritance Penting dalam Pengembangan?
Sebelum terlalu jauh membahas sintaks, penting untuk memahami alasan mengapa inheritance begitu vital. Dalam praktik pengembangan aplikasi berskala besar, kebutuhan untuk mengurangi duplikasi kode sangat penting.
Misalnya, tanpa inheritance, kita mungkin akan menulis properti merk dan tahun berulang kali di setiap class yang merepresentasikan jenis kendaraan. Hal ini tidak hanya membuang waktu, tetapi juga menyulitkan pemeliharaan.
Inheritance memecahkan masalah tersebut dengan:
- Mengurangi Redundansi: Sekali tulis di parent class, child class otomatis bisa menggunakannya.
- Meningkatkan Konsistensi: Jika ada perubahan di parent class, child class ikut merasakan dampaknya.
- Fleksibilitas Tinggi: Developer bisa menambahkan fungsionalitas spesifik di child class tanpa mengubah struktur utama.
Cara Menggunakan Inheritance di PHP
Di PHP, keyword extends digunakan untuk menerapkan inheritance. Sintaksnya sangat sederhana, namun memiliki dampak besar dalam desain sistem.
class ParentClass {
public function salam() {
echo "Halo dari ParentClass";
}
}
class ChildClass extends ParentClass {
public function salamAnak() {
echo "Halo dari ChildClass";
}
}
$child = new ChildClass();
$child->salam(); // Output: Halo dari ParentClass
Dengan satu baris extends, seluruh method dan properti dari parent bisa dipanggil langsung oleh child class.
Mengakses Method Parent dengan parent::
Kadang, child class perlu memanggil method dari parent class secara eksplisit. PHP menyediakan keyword parent:: untuk tujuan ini.
class Hewan {
public function suara() {
return "Hewan ini bersuara.";
}
}
class Kucing extends Hewan {
public function suara() {
return parent::suara() . " Lebih spesifik, ini suara kucing: Meong!";
}
}
$kucing = new Kucing();
echo $kucing->suara();
Dalam contoh ini, method suara milik parent tetap bisa diakses, lalu dikembangkan lebih lanjut oleh child class.
Properti dan Visibility dalam Inheritance
Tidak semua properti dan method bisa diwarisi secara bebas. PHP memiliki aturan visibility atau tingkat akses:
- public: Bisa diakses di mana saja, termasuk child class.
- protected: Hanya bisa diakses di dalam parent dan child class.
- private: Hanya bisa diakses di dalam parent class itu sendiri, tidak diwariskan ke child.
Contoh:
class Produk {
protected $harga;
private $diskon = 10;
public function setHarga($harga) {
$this->harga = $harga;
}
}
class Buku extends Produk {
public function getHarga() {
return $this->harga; // Bisa, karena protected
// return $this->diskon; // Error, karena private
}
}
Konsep visibility ini membantu menjaga keamanan data dalam OOP, sehingga tidak semua properti terbuka bebas.
Overriding Method pada Child Class
Inheritance tidak berarti child class hanya menyalin method parent begitu saja. Child class bisa meng-override atau menimpa method parent untuk kebutuhan spesifik.
class User {
public function role() {
return "User biasa";
}
}
class Admin extends User {
public function role() {
return "User dengan akses admin";
}
}
$admin = new Admin();
echo $admin->role(); // Output: User dengan akses admin
Dengan overriding, kita bisa menjaga struktur umum di parent class, namun tetap memberikan fleksibilitas tinggi pada child class.
Constructor dan Inheritance
Constructor (__construct) juga bisa diwarisi. Namun, jika child class memiliki constructor sendiri, maka constructor parent tidak otomatis dijalankan, kecuali dipanggil secara eksplisit dengan parent::__construct().
class Database {
public function __construct() {
echo "Koneksi database dibuat.";
}
}
class MySQL extends Database {
public function __construct() {
parent::__construct();
echo " Koneksi menggunakan MySQL.";
}
}
$db = new MySQL();
// Output: Koneksi database dibuat. Koneksi menggunakan MySQL.
Hal ini sering digunakan dalam desain aplikasi nyata, terutama ketika child class perlu menambahkan proses tambahan di samping proses bawaan dari parent.
Multiple Inheritance: Kenapa Tidak Ada di PHP?
PHP tidak mendukung multiple inheritance langsung (child class mewarisi lebih dari satu parent class). Hal ini untuk menghindari konflik jika dua parent memiliki method atau properti dengan nama sama.
Namun, PHP menyediakan alternatif berupa trait. Trait memungkinkan developer menuliskan ulang logika yang bisa digunakan oleh beberapa class tanpa perlu membuat inheritance berlapis.
trait Loggable {
public function log($pesan) {
echo "Log: $pesan";
}
}
class Aplikasi {
use Loggable;
}
$app = new Aplikasi();
$app->log("Aplikasi dijalankan");
Dengan trait, PHP tetap fleksibel sekaligus menghindari kompleksitas multiple inheritance.
Inheritance dalam Studi Kasus Nyata
Untuk memahami pentingnya inheritance, bayangkan kita sedang membuat sistem e-commerce. Kita memiliki class Produk dengan properti nama, harga, dan method getInfo().
Lalu, kita membuat child class seperti Buku, Elektronik, dan Pakaian. Semua produk ini memiliki properti dasar yang sama, sehingga cukup didefinisikan sekali di parent class.
Studi Kasus: Sistem Sekolah dengan Inheritance
Bayangkan kita membangun sistem sederhana untuk sekolah. Ada class Orang yang menyimpan data dasar seperti nama dan umur. Dari class ini, kita bisa membuat class Guru dan Siswa.
class Orang {
public $nama;
public $umur;
public function __construct($nama, $umur) {
$this->nama = $nama;
$this->umur = $umur;
}
public function info() {
return "$this->nama berusia $this->umur tahun.";
}
}
class Guru extends Orang {
public $mataPelajaran;
public function __construct($nama, $umur, $mataPelajaran) {
parent::__construct($nama, $umur);
$this->mataPelajaran = $mataPelajaran;
}
public function infoGuru() {
return $this->info() . " Mengajar mata pelajaran $this->mataPelajaran.";
}
}
class Siswa extends Orang {
public $kelas;
public function __construct($nama, $umur, $kelas) {
parent::__construct($nama, $umur);
$this->kelas = $kelas;
}
public function infoSiswa() {
return $this->info() . " Belajar di kelas $this->kelas.";
}
}
Dengan inheritance, informasi dasar orang hanya ditulis sekali. Class guru dan siswa bisa menambahkan detail spesifik masing-masing.
Studi Kasus: Manajemen Pegawai di Perusahaan
Dalam aplikasi HR (Human Resource), kita bisa membuat class dasar Pegawai. Kemudian class Manajer dan Staf bisa mewarisi class tersebut, namun tetap memiliki peran dan tunjangan berbeda.
class Pegawai {
public $nama;
public $gaji;
public function __construct($nama, $gaji) {
$this->nama = $nama;
$this->gaji = $gaji;
}
public function info() {
return "$this->nama dengan gaji Rp " . number_format($this->gaji, 0, ',', '.');
}
}
class Manajer extends Pegawai {
public $tunjangan;
public function __construct($nama, $gaji, $tunjangan) {
parent::__construct($nama, $gaji);
$this->tunjangan = $tunjangan;
}
public function totalGaji() {
return $this->gaji + $this->tunjangan;
}
}
class Staf extends Pegawai {
public $lembur;
public function __construct($nama, $gaji, $lembur) {
parent::__construct($nama, $gaji);
$this->lembur = $lembur;
}
public function totalGaji() {
return $this->gaji + ($this->lembur * 50000);
}
}
Inheritance di sini membuat logika penggajian mudah dikembangkan tanpa menulis ulang atribut dasar pegawai.
Studi Kasus: Transportasi Online
Aplikasi transportasi online biasanya memiliki beberapa jenis kendaraan, seperti mobil dan motor. Kita bisa membuat class dasar Kendaraan, lalu menurunkannya ke berbagai jenis kendaraan.
class Kendaraan {
public $platNomor;
public $driver;
public function __construct($platNomor, $driver) {
$this->platNomor = $platNomor;
$this->driver = $driver;
}
public function info() {
return "Driver $this->driver dengan plat $this->platNomor";
}
}
class MobilOnline extends Kendaraan {
public $jenis;
public function __construct($platNomor, $driver, $jenis) {
parent::__construct($platNomor, $driver);
$this->jenis = $jenis;
}
public function infoMobil() {
return $this->info() . " menggunakan mobil jenis $this->jenis.";
}
}
class MotorOnline extends Kendaraan {
public $helm;
public function __construct($platNomor, $driver, $helm) {
parent::__construct($platNomor, $driver);
$this->helm = $helm;
}
public function infoMotor() {
return $this->info() . " dengan helm $this->helm untuk penumpang.";
}
}
Dengan inheritance, fitur dasar kendaraan cukup dibuat sekali, sedangkan fitur spesifik seperti jenis mobil atau helm untuk motor bisa ditambahkan sesuai kebutuhan.
Studi Kasus: E-Wallet dan Transaksi Digital
Dalam sistem keuangan digital, kita bisa membuat class Transaksi sebagai induk. Dari situ, kita bisa menurunkan class Transfer, TopUp, dan Pembayaran.
class Transaksi {
public $jumlah;
public function __construct($jumlah) {
$this->jumlah = $jumlah;
}
public function detail() {
return "Transaksi sejumlah Rp " . number_format($this->jumlah, 0, ',', '.');
}
}
class Transfer extends Transaksi {
public $tujuan;
public function __construct($jumlah, $tujuan) {
parent::__construct($jumlah);
$this->tujuan = $tujuan;
}
public function detailTransfer() {
return $this->detail() . " ke rekening $this->tujuan.";
}
}
class TopUp extends Transaksi {
public $sumber;
public function __construct($jumlah, $sumber) {
parent::__construct($jumlah);
$this->sumber = $sumber;
}
public function detailTopUp() {
return $this->detail() . " dari sumber $this->sumber.";
}
}
class Pembayaran extends Transaksi {
public $merchant;
public function __construct($jumlah, $merchant) {
parent::__construct($jumlah);
$this->merchant = $merchant;
}
public function detailPembayaran() {
return $this->detail() . " untuk merchant $this->merchant.";
}
}
Di dunia nyata, konsep ini memudahkan developer dalam mengelola berbagai jenis transaksi tanpa menulis ulang logika utama.
