MODUL 3
Class Inheritance
Apa itu inheritance class? adalah sebuah mekanisme dimana kita dapat
menggunakan variabel atau method yang dimiliki class induk kepada class anaknya.
Kenapa ada mekanisme semacam ini di OOP? untuk mencegah redundansi
tentunya.
Bayangkan bila kamu memiliki class yang method - method-nya hampir sama baik
jumlah ataupun tujuannya, serta memiliki variabel yang sama juga kegunaannya.
Dalam OOP kita dapat mencegah redundansi penulisan kode tersebut
melalui inheritance class.
Sehingga nantinya class anak tidak perlu menulis ulang method yang ada
di class induk selama method yang sudah tersedia masih sesuai dengan tujuan yang
diperlukan. Bila tujuan sudah berbeda baik operasi, parameter, dan nilai yang
dikembalikan tapi namanya masih ingin sama. Maka harus dilakukan mekanisme
yang namanya overriding method.
Mari kita perhatikan contoh kode berikut:
<?php
class Hero {
protected $healthPoint;
protected $magicPoint;
protected $name;
public function sihir () {
echo "$this->name menyerang dengan sihir<br/>";
}
public function serang () {
echo "$this->name menyerang biasa<br/>";
}
public function tahan () {
echo "$this->name bertahan dari serangan musuh<br/>";
}
public function getHealthPoint() {
return $this->healthPoint;
}
public function getMagicPoint ()
{
return $this->magicPoint;
}
}
class SunGoKong extends Hero {
public function __construct()
{
$this->name = "Sun Go Kong";
$this->healthPoint = 9700;
$this->magicPoint = 1100;
}
}
class Susanoo extends Hero {
public function __construct()
{
$this->name = "Susanoo The King of Light";
$this->healthPoint = 9850;
$this->magicPoint = 1280;
}
}
class Ogre extends Hero{
public function __construct()
{
$this->name = "Ogre";
$this->healthPoint = 8700;
$this->magicPoint = 900;
}
}
$gokong = new SunGoKong();
$susanoo = new Susanoo();
$ogre = new Ogre();
$gokong->serang();
$gokong->sihir();
$gokong->tahan();
echo "HP: ".$gokong->getHealthPoint()."<br/>";
echo "MP: ".$gokong->getMagicPoint()."<br/>";
$susanoo->serang();
$susanoo->sihir();
$susanoo->tahan();
echo "HP: ".$susanoo->getHealthPoint()."<br/>";
echo "MP: ".$susanoo->getMagicPoint()."<br/>";
$ogre->serang();
$ogre->sihir();
$ogre->tahan();
echo "HP: ".$ogre->getHealthPoint()."<br/>";
echo "MP: ".$ogre->getMagicPoint()."<br/>";
Kita bisa melihat sendiri kan hanya dengan menggunakan inheritance class, kita
dapat membuat class dengan nama yang berbeda - beda namun dengan
menggunakan sejumlah method yang sama dari class induk. Untuk melakukan ini,
kita harus menggunakan keyword extends terhadap class anak dan
menujuk class induk yang diinginkan.
Selain itu pada potongan kode diatas, kita dapat membuat beberapa class dengan
nama berbeda dan default value-nya yang berbeda pula untuk menciptakan
karakteristik yang tidak sama antara class yang disediakan.
Potongan kode diatas bila kita jalankan akan muncul seperti berikut:
$ php [Link]
Sun Go Kong menyerang biasa
Sun Go Kong menyerang dengan sihir
Sun Go Kong bertahan dari serangan musuh
HP: 9700
MP: 1100
Susanoo The King of Light menyerang biasa
Susanoo The King of Light menyerang dengan sihir
Susanoo The King of Light bertahan dari serangan musuh
HP: 9850
MP: 1280
Ogre menyerang biasa
Ogre menyerang dengan sihir
Ogre bertahan dari serangan musuh
HP: 8700
MP: 900
Melakukan N-Inheritance
Tidak berbeda jauh dengan inheritance class yang telah dipaparkan sebelumnya.
Hanya saja N-Inheritance ini dilakukan terhadap class yang sudah
melakukan inheritance terhadap suatu class induk. Sehingga class tersebut menjadi
induk dari class lain. Atau kita dapat menganggapnya
melakukan inheritance beberapa kali.
Inheritance macam ini biasa dilakukan bila ada suatu class yang harus dibuat
generik namun dia dapat memilih siapa class induknya. Tergantung kebutuhan.
Mari kita perhatikan contoh kode berikut:
<?php
class DB {
public function getConnection() {
echo "Memanggil getConnection()...<br/>";
}
public function getConfig() {
echo "Memanggil getConfig()...<br/>";
}
}
class BaseModel extends DB {
public function select () {
echo "Melakukan query select...<br/>";
}
public function selectByID($id) {
echo "Melakukan query select by id - $id...<br/>";
}
public function insert () {
echo "Melakukan query insert...<br/>";
}
public function update () {
echo "Melakukan query update...<br/>";
}
public function delete () {
echo "Melakukan query delete...<br/>";
}
}
class TransactionModel extends BaseModel {
public function getDailyReport() {
echo "Menghasilkan daily report <br/>";
}
public function getMonthlyReport() {
echo "Menghasilkan monly report";
}
}
class UserModel extends BaseModel {
public function authenticate() {
echo "Melakukan authentikasi user <br/>";
}
public function changePassword() {
echo "Melakukan penggantian password";
}
public function updateProfile() {
echo "Melakukan update password";
}
}
$tm = new TransactionModel();
$tm->getConnection();
$tm->getConfig();
$tm->select();
$tm->selectByID(10);
$tm->insert();
$tm->update();
$tm->delete();
$tm->getDailyReport();
$tm->getMonthlyReport();
$um = new UserModel();
$um->getConnection();
$um->getConfig();
$um->select();
$um->selectByID(10);
$um->insert();
$um->update();
$um->delete();
$um->authenticate();
$um->changePassword();
$um->updateProfile();
Pada kode diatas ada sebuah class bernama DB. Class tersebut kita simpan karena
digunakan untuk menyimpan konfigurasi ke suatu database. Lalu
ada class BaseModel yang mewarisi apa saja yang ada di class DB. Barulah setelah
itu model - model yang memiliki method yang tidak sama dengan model lain
mewarisi BaseModel karena pada dasarnya setiap class memiliki method yang sama
untuk tujuan CRUD.
Potongan kode diatas bila kita jalankan akan muncul seperti berikut:
$ php [Link]
Memanggil getConnection()...
Memanggil getConfig()...
Melakukan query select...
Melakukan query select by id - 10...
Melakukan query insert...
Melakukan query update...
Melakukan query delete...
Menghasilkan daily report
Menghasilkan monly reportMemanggil getConnection()...
Memanggil getConfig()...
Melakukan query select...
Melakukan query select by id - 10...
Melakukan query insert...
Melakukan query update...
Melakukan query delete...
Melakukan authentikasi user
Melakukan penggantian passwordMelakukan update password
Polymorphism
Seperti yang telah jelaskan sebelumnya, polimorfisme adalah proses menciptakan
beberapa objek dari kelas tertentu. Sebagai contoh, lihat contoh kasus berikut. Kita
membutuhkan tiga kelas
yaitu Emailer, ExtendedEmailer dan HtmlEmailer (anggap saja kelas ini telah
dibuat dengan berbagai method didalamnya). Mari kita lihat kode berikut:
<?php
include("[Link]");
include("[Link]");
include("[Link]");
$Emailer = new Emailer("hani@[Link]");
$ExtendedEmailer = new ExtendedEmailer();
$HtmlEmailer = new HtmlEmailer("hani@[Link]");
if ($ExtendedEmailer instanceof Emailer)
echo "Extended Emailer is Derived from Emailer.<br/>";
if ($HtmlEmailer instanceof Emailer )
echo "HTML Emailer is also Derived from Emailer.<br/>";
// Tidak akan keluar output karena Emailer bukan instance
HTMLEmailer
if ($Emailer instanceof HtmlEmailer )
echo "Emailer is Derived from HTMLEmailer.<br/>";
// Tidak akan keluar output karena HTMLEmailer bukan instance
Extended
if ($HtmlEmailer instanceof ExtendedEmailer )
echo "HTML Emailer is Derived from Emailer.<br/>";
?>
Jika kamu menjalankan skrip di atas, kamu akan menemukan output berikut:
Extended Emailer is Derived from Emailer.
HTML Emailer is also Derived from Emailer.
Itulah contoh penggunaan polymorphism, yaitu penggunaan method yang sama
dengan fungsi yang berbeda-beda.
Memisahkan Search City Menjadi Component
Override Method
Sesuai dengan namanya, overriding, kita dapat menimpa sebuah cara kerja
suatu method di dalam class yang kita extend. Lalu ditimpa dengan logika yang kita
butuhkan atau dimodifikasi. Namun salah satu ketentuanya adalah nama dan
argumen yang dibutuhkan harus sama.
Mari kita perhatikan contoh kode berikut:
<?php
class Animal {
public function speak() {
echo "Hewan sedang bersuara!<br/>";
}
}
class Dog extends Animal {
public function speak() {
echo "Guk guk guk guk!<br/>";
}
}
$d = new Dog();
$d->speak();
Pada kode diatas kita harus
mengimplementasikan method speak() dari class Animal di-override di
dalam class Dog. Bila kita jalankan akan muncul output seperti berikut:
$ php [Link]
Guk guk guk guk!
Bukannya keluar output yang sebelumnya, tapi output yang ditampilkan
adalah output hasil override.
Menggunakan Method Induk Sebelum dilakukan Overriding
Untuk menggunakan fungsionalitas suatu method dari class induk, kita dapat
membuat method lain dan memanggil method speak() dengan menggunakan
tanda parent::speak() .
Mari kita perhatikan contoh kode berikut:
<?php
class Animal {
public function speak() {
echo "Hewan sedang bersuara!<br/>";
}
}
class Dog extends Animal {
public function speak() {
echo "Guk guk guk guk!<br/>";
}
public function verboseSpeak()
{
parent::speak();
$this->speak();
}
}
$d = new Dog();
$d->speak();
$d->verboseSpeak();
Sekarang mari kita jalankan dan lihat perbedaannya:
$ php [Link]
Guk guk guk guk!
Hewan sedang bersuara!
Guk guk guk guk!
Bila kita gunakan parent::speak() maka kita dapat memanggil fungsionalitas
dari class induk sebelum di-override.
Interface
Interface adalah sebuah aturan dalam OOP dimana kita dapat membuat sebuah
ketentuan yang harus selalu diimplementasikan dalam suatu kelas. Misal terdapat
sebuah fungsionalitas dari CRUD data Posts/Artikel. Di dalamnya terdapat method
select, insert, update, dan delete.
Bila salah satunya tidak diimplementasikan oleh programmer, maka saat runtime
atau kompilasi akan terjadi error, karena programmer tersebut menyalahi aturan
yang ditentukan dalam pembuatan suatu class
Mari kita perhatikan contoh kode berikut :
<?php
error_reporting(E_ALL);
ini_set('display_errors', 1);
// Interface pada sebuah CRUD
interface Crud {
public function insert();
public function update();
public function select();
public function delete();
}
// Buah class yang mengurusi data Posts, misal artikel.
class Posts implements Crud {
public function insert() {
echo "Call method insert ..\n";
}
public function update() {
echo "Call method update ..\n";
}
public function select() {
echo "Call method select ..\n";
}
}
$posts = new Posts;
$posts->insert();
$posts->update();
$posts->select();
?>
Pada kode diatas kita membuat sebuah interface Crud dan class Posts. Ceritanya
Posts bertugas mengolah data tabel posts pada sebuah database. Bisa kita lihat,
class Posts tidak membuat method delete. Kode diatas akan menghasilkan error
seperti ini :
Fatal error: Class Posts contains 1 abstract method and must
therefore be declared abstract or implement the remaining methods
(Crud::delete) in /path/to/[Link] on line 14
Nah, disini kita belajar bahwa kita harus implementasi semua method pada interface
setelah meng-implements. Mari kita perbaiki lagi kode jadi seperti ini :
<?php
error_reporting(E_ALL);
ini_set('display_errors', 1);
// Interface pada sebuah CRUD
interface Crud {
public function insert();
public function update();
public function select();
public function delete();
}
// Buah class yang mengurusi data Posts, misal artikel.
class Posts implements Crud {
public function insert() {
echo "Call method insert ..\n";
}
public function update() {
echo "Call method update ..\n";
}
public function select() {
echo "Call method select ..\n";
}
public function delete() {
echo "Call method delete ..\n";
}
}
$posts = new Posts;
$posts->insert();
$posts->update();
$posts->select();
$posts->delete();
?>
Silahkan coba jalankan kode diatas dengan browser atau PHP CLI. Maka bisa
ditebak, kode diatas akan lancar-lancar saja dan menghasilkan output seperti ini :
Call method insert ..
Call method update ..
Call method select ..
Call method delete ..
Multi Implementasi Interface pada Class di PHP
Bila contoh sebelumnya hanya menggunakan satu interface maka sekarang kita
akan mencoba menggunakan beberapa interface pada suatu class. Masih dengan
kasus yang sama. Mari kita perhatikan contoh kode berikut:
<?php
error_reporting(E_ALL);
ini_set('display_errors', 1);
// Interface pada sebuah CRUD
interface Crud {
public function insert();
public function update();
public function select();
public function delete();
}
// Interface Wipe, misalnya untuk fasilitas menghapus semua data,
hanya contoh.
interface Wipe {
public function wipe();
}
// Buat class yang mengurusi data Posts, misal artikel.
// Disini kita implement Crud dan Wipe, tinggal gabungkan dengan
koma saja.
class Posts implements Crud, Wipe {
public function insert() {
echo "Call method insert ..\n";
}
public function update() {
echo "Call method update ..\n";
}
public function select() {
echo "Call method select ..\n";
}
public function delete() {
echo "Call method delete ..\n";
}
// Wajib membuat method wipe, karena sudah di implement.
public function wipe() {
echo "Call method wipe ..\n";
}
}
$posts = new Posts;
$posts->insert();
$posts->update();
$posts->select();
$posts->delete();
$posts->wipe();
?>
Pada potongan kode diatas, kita hanya perlu memisahkan dengan tanda koma untuk
menggunakan beberapa interface . Dan setiap method di dalam interface yang
berbeda harus diimplementasikan semuanya di dalam class yang menggunakannya.
Hasil kode diatas adalah :
Call method insert ..
Call method update ..
Call method select ..
Call method delete ..
Call method wipe ..
Bisa dipahami? mudah bukan.