Dalam pemrograman berorientasi objek, istilah overriding method sering muncul ketika membahas konsep inheritance (pewarisan). PHP sebagai bahasa pemrograman yang mendukung OOP, memberikan kemampuan kepada developer untuk mengatur ulang perilaku sebuah method yang diwarisi dari parent class. Dengan memahami overriding, kita bisa menulis kode yang lebih fleksibel, terstruktur, sekaligus mudah dikembangkan.
Artikel ini akan mengupas tuntas konsep overriding method di PHP, mulai dari pengertian, aturan yang berlaku, hingga praktik nyata dalam implementasinya.
Apa Itu Overriding Method?
Overriding method adalah kemampuan sebuah subclass untuk menulis ulang (menggantikan) implementasi method yang diwarisi dari parent class. Artinya, meskipun sebuah method sudah didefinisikan di parent, kita dapat membuat versi baru di child class yang memiliki logika berbeda sesuai kebutuhan.
Dengan overriding, developer bisa memastikan bahwa objek turunan dapat berperilaku berbeda meski memiliki struktur yang sama. Konsep ini penting untuk menjaga fleksibilitas dan mendukung prinsip polymorphism dalam OOP.
Aturan Dasar dalam Overriding Method di PHP
Sebelum langsung ke praktik, ada beberapa aturan mendasar yang harus dipahami agar overriding bisa berjalan dengan benar.
Nama Method Harus Sama
Subclass harus menggunakan nama method yang identik dengan method di parent class. Jika berbeda, maka dianggap method baru, bukan overriding.
Aksesibilitas Tidak Boleh Lebih Ketat
Hak akses method (public, protected, private) tidak boleh diperketat saat overriding. Misalnya, method public di parent tidak boleh diturunkan menjadi protected atau private di child class.
Tipe Parameter dan Return Harus Konsisten
Sejak PHP 7, aturan strict typing membuat developer perlu menjaga kesesuaian parameter dan return type agar tidak terjadi error.
Dukungan Keyword parent::
Saat melakukan overriding, kita masih bisa memanggil implementasi parent menggunakan parent::methodName().
Contoh Sederhana Overriding Method di PHP
Untuk memahami lebih jelas, mari kita lihat contoh kode dasar berikut:
<?php
class Hewan {
public function suara() {
return "Hewan mengeluarkan suara.";
}
}
class Kucing extends Hewan {
public function suara() {
return "Meong!";
}
}
$hewanUmum = new Hewan();
echo $hewanUmum->suara(); // Output: Hewan mengeluarkan suara.
$kucing = new Kucing();
echo $kucing->suara(); // Output: Meong!
Pada contoh di atas, method suara() pada class Hewan dioverride oleh class Kucing. Hasilnya, meski kedua objek memiliki method yang sama, output yang dihasilkan berbeda sesuai implementasi masing-masing.
Menggunakan parent:: dalam Overriding
Ada kalanya kita ingin menambahkan logika baru di child class tanpa sepenuhnya menghapus logika di parent class. Untuk itu, PHP menyediakan keyword parent::.
<?php
class Kendaraan {
public function info() {
return "Ini adalah kendaraan.";
}
}
class Mobil extends Kendaraan {
public function info() {
return parent::info() . " Lebih spesifik: ini adalah mobil.";
}
}
$mobil = new Mobil();
echo $mobil->info();
// Output: Ini adalah kendaraan. Lebih spesifik: ini adalah mobil.
Dengan cara ini, implementasi di parent tetap digunakan, tetapi ditambahkan logika baru di child.
Overriding Method vs Overloading Method
Sering kali, developer pemula bingung membedakan antara overriding dan overloading.
- Overriding → Mengganti implementasi method parent di child class dengan nama yang sama.
- Overloading → Membuat method dengan nama yang sama tetapi parameter berbeda.
PHP tidak mendukung overloading secara tradisional seperti Java atau C++, melainkan memiliki konsep magic method __call() untuk menangani pemanggilan method dinamis.
Penerapan Overriding dalam Polymorphism
Polymorphism memungkinkan objek dengan parent yang sama berperilaku berbeda. Overriding adalah salah satu cara untuk mewujudkannya di PHP.
<?php
class Pegawai {
public function gaji() {
return 3000000;
}
}
class Manager extends Pegawai {
public function gaji() {
return 7000000;
}
}
class Direktur extends Pegawai {
public function gaji() {
return 15000000;
}
}
$pegawai = new Pegawai();
$manager = new Manager();
$direktur = new Direktur();
echo "Pegawai: " . $pegawai->gaji() . PHP_EOL;
echo "Manager: " . $manager->gaji() . PHP_EOL;
echo "Direktur: " . $direktur->gaji() . PHP_EOL;
Dengan overriding, setiap subclass dapat memberikan nilai gaji berbeda meski memanggil method yang sama. Inilah esensi polymorphism dalam OOP.
Dampak Penggunaan final pada Overriding
Jika sebuah method diberi keyword final, maka method tersebut tidak bisa dioverride oleh subclass.
<?php
class Produk {
final public function info() {
return "Informasi produk.";
}
}
class Buku extends Produk {
// Error: Cannot override final method
public function info() {
return "Informasi buku.";
}
}
Keyword final berguna ketika kita ingin memastikan sebuah method tidak diubah oleh turunan mana pun.
Overriding Method dalam Konteks Abstract Class
Abstract class sering digunakan untuk menentukan blueprint yang harus diikuti subclass. Dalam hal ini, overriding bukan hanya opsional, melainkan wajib.
<?php
abstract class Bentuk {
abstract public function luas();
}
class Persegi extends Bentuk {
private $sisi;
public function __construct($sisi) {
$this->sisi = $sisi;
}
public function luas() {
return $this->sisi * $this->sisi;
}
}
$persegi = new Persegi(5);
echo $persegi->luas(); // Output: 25
Karena method luas() di Bentuk bersifat abstract, maka Persegi wajib menuliskan ulang method tersebut. Inilah bentuk overriding yang mendasar pada abstract class.
Overriding Method dengan Interface
Selain abstract class, interface juga mewajibkan implementasi method di dalam subclass. Perbedaan utamanya, interface hanya berisi deklarasi tanpa implementasi.
<?php
interface Kendaraan {
public function bergerak();
}
class Sepeda implements Kendaraan {
public function bergerak() {
return "Sepeda dikayuh.";
}
}
class Motor implements Kendaraan {
public function bergerak() {
return "Motor melaju dengan bensin.";
}
}
Dalam konteks interface, overriding lebih tepat disebut implementasi, karena setiap class yang mengikat kontrak interface harus menuliskan ulang semua method yang didefinisikan.
Studi Kasus: Overriding untuk Sistem Pembayaran
Bayangkan kita sedang membangun sistem pembayaran. Parent class berisi method dasar prosesPembayaran(), lalu setiap metode pembayaran seperti Transfer Bank, E-Wallet, atau Kartu Kredit bisa memiliki implementasi berbeda.
<?php
class Pembayaran {
public function prosesPembayaran($jumlah) {
return "Memproses pembayaran sejumlah Rp" . $jumlah;
}
}
class TransferBank extends Pembayaran {
public function prosesPembayaran($jumlah) {
return "Pembayaran Rp" . $jumlah . " via Transfer Bank berhasil.";
}
}
class EWallet extends Pembayaran {
public function prosesPembayaran($jumlah) {
return "Pembayaran Rp" . $jumlah . " melalui E-Wallet sukses.";
}
}
$transfer = new TransferBank();
$ewallet = new EWallet();
echo $transfer->prosesPembayaran(500000) . PHP_EOL;
echo $ewallet->prosesPembayaran(250000);
Studi kasus ini menunjukkan bagaimana overriding dapat membuat sistem lebih dinamis, mudah diperluas, dan mendukung berbagai kebutuhan bisnis.
