Inheritance atau pewarisan memungkinkan penciptaan kelas baru yang mewarisi properti dan metode dari kelas induk. Kelas turunan dapat menambahkan atau menimpa perilaku asli serta mewarisi akses level dari properti dan metode kelas induk. Pewarisan tunggal dan ganda merupakan jenis pewarisan utama dalam pemrograman berorientasi objek.

1. Inheritance atau pewarisan adalah kalimat yang pasti ada di dalam pemerograman
berorientasi objek disebut juga dengan istilah reusable.
Salah satu kelebihan menggunakan sebuah kelas yaitu kita dapat membuat kelas inherits.
Pewarisan (inheritance) dilakukan dengan memperpanjang (extends) kelas yang sudah
ada dengan cara membuat kelas baru yang mewarisi (inherits) semua properti dan metode
yang ada pada kelas aslinya (parent class).
Ketika menggunakan kembali atau mengganti method dari class yang sudah ada, serta
ketika menambahkan field instant dan method baru, maka pada saat itulah Anda bekerja
dengan inheritance. Konsep ini merupakan konsep yang fundamental dalam orientasi
objek dan harus digunakan dengan baik, ada beberapa macam Inheritance atau pewarisan
yang ada di dalam OOP Single Inheritance dan Multple Inheritance
- Single Inheritance
- Multiple Inheritance
dalam penggunaan inheritance class Induk akan mewariskan semua atribut yang ia miliki
sehingga class bawahnya akan memilki atribut yang sama dengan class induk, bahkan
dapat memilki kebabasan untuk memilki atribut berbeda dengan class induknya berikut
ilustrasi dalam php
catatan :
sampai sekarang PHP belum mendukung multiple inheritance seperti C++ walapun PHP
dan c/c++ begitu banyak kemiripannya, dan perubahan PHP versi 5 ditekankan pada OOP
salah satunya adalah beberapa tambahan untuk kemampuan inheritance
contoh pewarisan
<?php
class Bapak {
var $nama =”Bapak”;
function Bapak($n) {

2. $this->nama = $n;
}
function Hallo() {echo “Halo, saya $this->nama
”;}
}
class Anak extends Bapak {}
$test = new Anak(”Anak dari Bapak”);
$test->Hallo();
?>
Hasil tampilan dari listing program di atas adalah “Halo, saya Anak dari Bapak” dan
bukannya “Halo, saya Bapak”. Mengapa demikian? Memang di dalam class Bapak
didefinisikan variabel nama dengan nilai Bapak, selanjutnya kita membuat objek dari
class Anak yang merupakan turunan dari class Bapak. Lihat bahwa instantiasi sekaligus
mengisikan parameter baru “Anak dari Bapak”, sehingga ketika dipanggil maka
mengisikan $this->nama dengan parameter tersebut. Ada pun di dalam implementasi
pemrograman, kebanyakan pemrogram merasakan beberapa manfaat dari inheritance atau
pewarisan, diantaranya:
Subclass mampu menyediakan perilaku khusus dari elemen dasar yang disediakan oleh
superclass.
Pemrogram dapat mengimplementasikan superclass untuk memanggil class abstrak yang
menyatakan perilaku umum.
Contoh lagi :
<?php
// parent class
class jenisMakanan {
public $public = "krupuk udang";
protected $protected = "enak sekali";
private $private = "tidak enak";
// metode/fungsi disini
}
// inherits class
class rasaMakanan extends jenisMakanan {
function rasa1() {
echo $this->public . " " . $this->protected;
}
function rasa2() {

3. echo $this->public . " " . $this->private;
}
}
$makanan = new rasaMakanan();
$makanan->rasa1(); // Hasil: krupuk udang enak sekali
$makanan->rasa2(); // Hasil: krupuk udang
?>
Pada contoh diatas, terlihat jelas bahwa properti public dan protected dapat
ditampilkan dengan memanggil obyek yang ada pada kelas inherits, yaitu kelas
rasaMakanan. Sedangkan properti private tidak dapat ditampilkan pada kelas inherits
tersebut. Perlakuan access modifiers pada metode-metode yang ada pada kelas tersebut
sama perlakuannya terhadap properti-properti seperti yang sudah dijelaskan.
Contoh maning :
<?php
class KendBermotor {
public $mesin;
private $roda;
protected $jalur;
function __construct() {
$this->mesin = "Kendaraan Bermotor Punya Mesin <br>";
$this->roda = "Kendaraan Bermotor Punya Roda <br>";
$this->jalur = "Kendaraan Bermotor Punya Jalur <br>";
}
function getMesin() {
return $this->mesin;

4. }
function getJalur() {
return $this->jalur;
}
function getRoda() {
return $this->roda;
}
}
// Class turunan dari KendBermotor
class KapalLaut extends KendBermotor {
private $baling2;
function __construct() {
// Dapat dijalankan
$this->mesin = "Kapal Laut Punya Mesin <br>";
$this->jalur = "Kapal Laut Punya Jalur <br>";
$this->baling2 = "Kapal Laut Punya Baling-baling <br>";
// Tidak dapat diakses
$this->roda = "Kapal Laut Punya Roda";
}
function getBaling2() {
return $this->baling2;
}
}
$KB = new KendBermotor();
echo "<p><b> Kriteria Kendaraan Bermotor : </b><br>";
echo $KB->getMesin();
echo $KB->getRoda();
echo $KB->getJalur();
$KL = new KapalLaut();
echo "<p><b> Kriteria Kapal Laut : </b><br>";
// Dapat diakses
echo $KL->getMesin();
echo $KL->getBaling2();
echo $KL->getJalur();
?>
Hasilnya : ??????????

5. Example again :
<?
class Kendaraan{
//atribut-atribut
var $merek,$jmlroda;
//konstruktor
function __construct($m){
$this->merek=$m;
}
//method-method...
function tampilkanMerek(){
return $this->merek;
}
function isiJmlRoda($jml){
$this->jmlroda=$jml;
echo " Jumlah rodanya ".$this->jmlroda;
}
function bergerak($arah){
echo " bergerak ke arah ".$arah;
}
}
//instansiasi kelas Kendaraan menjadi object $kijang
$kijang = new Kendaraan("Kijang");
echo "Sebuah kendaran bermerek ".$kijang->tampilkanMerek();
$kijang->isiJmlRoda(4);
$kijang->bergerak("Utara");
class Motor extends Kendaraan{
var $harga;
function __construct($mrk,$hrg){
//akses konstruktor Kendaraan (super)
parent::__construct($mrk);
$this->harga = $hrg;
}
function tampilkanHarga(){
return $this->harga;
}
function bergerak($arah){
echo "maju ke arah $arah";
}
}
//instansiasi kelas Motor menjadi object $honda
$honda = new Motor("Honda",12000000);
echo "Sebuah Kendaraan bermerek ".$honda->tampilkanMerek()."
dengan harga Rp.";
printf(number_format($honda->tampilkanHarga(),2,',','.'));

6. $honda->isiJmlRoda(2);
$honda->bergerak("Selatan");
?>
Setelah object $honda memberi tahu merek dan harganya, dia mengisi jumlah roda
dengan menthod kelas Kendaraan, tapi bergerak dengan method khusus kelas Motor.
Kelas turunan akan mewariskan atribut-atribut dan method-method baseclass/parentclass-
nya.
Ketika $honda mengisi jumlah roda, dia mengisi jumlah roda dengan method Kendaraan,
tetapi ketika bergerak, dia bergerak dengan method baru yang didefinisikan khusus pada
kelas Motor(“maju ke arah $arah”), inilah yang disebut dengan method overriding, yaitu
suatu kondisi di mana derived class menolak method base / parent classnya.