| [SHARING] Beberapa malam sebelumnya terjadi disku... Oct 25th 2012, 10:00, by Zlumber Jay | | [SHARING] Beberapa malam sebelumnya terjadi diskusi panjang tentang Interface dan Abstract, kamu berikan beberapa contoh walau mungkin tidak sempurna tapi semoga ada manfaat bagi semua :
INTERFACE
- Mendefenisikan method "kepala()" seperti dalam contoh yang belum diimplementasikan
- Menggunakan "implements" untuk diturunkan
contoh :
<?php
Interface Ayam{
function kepala();
}
class anakAyam implements Ayam {
public $telur;
public $daging;
public $kandang;
function kepala(){
}
}
?>
ABSTRACT
sama dengan interface method "Kepala()" belum dimplementasikan
menggunakan extends untuk diturunkan
contoh :
<?php
abstract class Ayam{
function Betina(){
}
abstract function kepala();
public $telur;
public $daging;
public $kandang;
}
class Jantan extends Ayam{
function kepala(){
//implementasi
}
}
?>
Catatan :
Perhatikan alur/posisi function kepala() |
| | | makasih om ilmunya |
| | | Asik d bahas mastah,,, |
| | | Yg interface,,
function kepala(); // ini kalo d hapus n gak, ada pengaruhnya ??? |
| | | Gembel Berkelas saya tdk mengatakan tidak ada pengaruhnya mungkin suatu saat tahu perbedaan jika ditambahkan :
<?php
Interface Ayam{
function kepala($telur, $daging, $kandang);
}
dan mungkin anda mendapatkan error
menurut saya kepala () hanya method function yang berbentuk abstrak atau seperti ga ngaruh tapi tujuan untuk dimplementasikan kemudian dan bukaan saat itu. |
| | | Ah mastah,,, ane kan nanya,, bener2 pengen tau,,,
Kasih bentuk yg bisa memperlihatkan apa itu "interface" sebenernya dund mastah,,,, tp yg simple aja (jgn tlalu tinggi).
* serius pengen ngerti. |
| | | Ah ane tdk mau sotoy, ane juga butuh masukan darimana saja. Karena nantinya rangkumannya saya mau simpan di wordpress |
| | | mas Zlumber Jay berarti setiap ada perubahan (method) pada interface maka class yang reference ke interface tersebut harus dirubah juga ya? |
| | | kita tunggu saja masukan dari teman2 yang lain |
| | | Gpp mastah sotoy juga,,,,
Yg penting ane bisa paham, kalo yg d php manual mah lieur,,,
* maklum IQ ane cuma rata2,
:serius: |
| | | Gembel Berkelas
coba test skrip tentang abstrak ini :
Jika anda mentest langsung hasilnya:
Kelas Dua memanggil :
fungsi dari Kelas Dua
Kelas Tiga memanggil :
fungsi dari Kelas Satu <---- otomatis dipanggil kelas satu
tapi jika anda membuang tanda // maka hasilnya :
Kelas Dua memanggil :
fungsi dari Kelas Dua
Kelas Tiga memanggil :
fungsi dari Kelas Tiga <---- kelas satu tidak dipanggil lagi
Contoh :
<?php
abstract class Satu{
public function disp(){
echo " fungsi dari Kelas Satu <br/>";
}
}
class Dua extends Satu{
public function disp(){
echo "fungsi dari Kelas Dua<br/>";
}
}
class Tiga extends Satu{
//public function disp(){
//echo "fungsi dari Kelas Tiga <br/>";
}
//}
$two=new Dua();
echo "<b>Kelas Dua memanggil :</b><br/>";
$two->disp();
$three=new Tiga();
echo "<b>Kelas Tiga memanggil :</b><br/>";
$three->disp();
?>
Kesimpulan sementara abstrak menncerminkan kelas tanpa bentuk, dia datang jika function tidak ada, tapi jika function di isi maka abstrak kelas menyingkir |
| | | Ane yg sama sekali gak paham2 tuh yg interfacenya om,,,
Kalo yg abstract class mah yah bisalah walo cuma secuil, kesimpulan ane ntu untuk alternatif yg 'mungkin' undefined method d class yg d extends, trus abstract class gak bisa d jadikan body buat object (harus d extends),,, menurut ane (ada benernya gak sih ??? Apa ane ngawur ea ? )
Tp kalo interface mah suwer, gak paham2,, disuruh ngasal atau ngarang bebas juga ane gak bisa2,,,, |
| | | Interface adalah blueprint class yang akan kita buat, kegunaannya adalah untuk menetapkan method2 yang harus ada pada class yang mengimplement Interface. Method2 yang ada di Interface sifatnya hanya definisi Method saja, jadi tidak ada Script isinya, dan pastinya tidak ada return;
contoh:
Interface Ayam{
function kepala($telur, $daging, $kandang);
function kaki();
}
maka class yang mengimplement Interface minimal harus seperti ini
class Ayamclass implements Ayam
{
function kepala($telur, $daging, $kandang){ }
function kaki(){ }
}
jadi class yang mengimplement Interface harus menurunkan semua method yang ada pada Interface |
| | | Abstract Class agak mirip dengan Interface, Abstract Class juga berfungsi sebagai Blueprint. Bedanya jelas, Abstract Class adalah sebuah Class, jadi perlakuannya mirip dengan Class. Yaitu Method2 yang ada di Abstract Class bisa diisi Script, layaknya Class biasa, kecuali Method2 yang diawali keyword Abstract. Method2 yang diawali keyword Abstract ini sama dengan method yang ada di Interface, hanya bersifat Definisi, tidak ada script isi, dan tidak ada return.
Abstract Class ini juga tidak bisa langsung dipergunakan/dipanggil. Tapi harus diturunkan dulu ke Class biasa. Class yang menurunkan Class Abstract, harus menurunkan semua method abstract. Kalo Classnya tidak menurunkan semua Method Abstract, maka Class tersebut harus dijadikan Class Abstract. Hal ini juga berlaku di Interface, Class yang tidak menurunkan seluruh Method dari Interface yang diimplement, harus menjadi Class Abstract.
contoh penggunaan abstract class...
abstract class userabstract{
public function getname()
{
return 'awaludin';
}
abstract public function getpermission();
abstract public function getaddress();
}
abstract class User Extends UserAbstract
{
public function getpermission()
{ }
}
class newUser extends User{
public function getaddress()
{ }
}
$user=new newUser();
echo $user->getname(); |
| | | lawanannya abstract adalah final.......nanti akan dibahas........hehe |
| | | Gembel Berkelas : interface itu dasarnya kita membuat suatu sistem polimorfisme dengan menambahkan behaviour ke suatu object, perlu diinget interface itu spesifik ke behaviour. Tujuan dari polimorfisme sendiri salah satunya adalah membuat suatu object itu loose-coupled dengan object lain,, contoh penggunaan interface kira2 seperti ini (ambil contoh object ayam kayak diatas)
interface BerkokokBehaviour
{
public function cara_berkokok();
}
class BerkokokSambilTidur implements BerkokokBehaviour
{
public function cara_berkokok()
{
// code untuk berkokok sambil tidur
}
}
class BerkokokSambilMelek implements BerkokokBehaviour
{
public function cara_berkokok()
{
// code untuk berkokok sambil melek
}
}
class Ayam
{
private BerkokokBehaviour $berkokok;
public function __construct(BerkokokBehaviour $berkokok)
{
$this->berkokok = $berkokok;
}
public function berkokoklah()
{
$this->berkokok->cara_berkokok();
}
}
code di client :
BerkokokBehaviour $berkokok = new BerkokokSambilMelek();
Ayam $ayam = new Ayam();
$ayam->berkokoklah();
perhatikan, object ayam tidak perlu tahu implementasi dari BerkokokBehaviour $berkokok , sehingga membuat kode kita loose-coupled dan tidak dependent ke spesifik object (BerkokokSambilTidur atau BerkokokSambilMelek) |
| | | Pajang lagi ah.... Coding Hello World OOP, lengkap dengan class abstract dan interface. https://gist.github.com/2559703 |
| | | IMHO mas Awaludin Rahmadi , interface bukan sekedar kontrak method,, dan sbenernya buat apa ada kontrak method? Interface ataupun abstract tujuannya akhirnya cuma satu yaitu polimorfisme. bedanya kalo interface kita bisa inject suatu behaviour sedangkan kalo pake abstract kita bisa membuat class turunan (extends) yang mewarisi method dan properti dari class parent . CMIIW |
| | | Dewa pada nongol semua,,,,
:nyimak: |
| | | Glend Maatita
kyknya kurang dikit deh hehe
Ayam $ayam = new Ayam($berkokok); |
| | | Di class ayam nya mas glend
Ada 'berkokokbehaviour' sbelum $berkokok
Ada penjelasannya ??? ( ane baru liat yg kea gitu ) |
| | | "bedanya kalo interface kita bisa inject suatu behaviour sedangkan kalo pake abstract kita bisa membuat class turunan (extends) yang mewarisi method dan properti dari class parent" => Abstract juga bisa dipakai sebagai quality injector, eg (merujuk contoh diatas):
========
abstract class BerkokokBehaviour
{
abstract public function cara_berkokok();
}
class BerkokokSambilMelek extends BerkokokBehaviour
{
public function cara_berkokok()
{
// code untuk berkokok sambil melek
}
}
class Ayam
{
private $berkokok;
public function __construct(BerkokokBehaviour $berkokok)
{
$this->berkokok = $berkokok;
}
public function berkokoklah()
{
$this->berkokok->cara_berkokok();
}
}
========
Kalau dari diskusi di http://www.facebook.com/groups/35688476100/permalink/10151269341066101, perbedaanya ada di :
1. Interface murni cuman shell(cangkang), sementara abstract bisa punya concrete method. Saking kaku-nya interface, bahkan const di interface tidak dapat di-overide (berbeda dengan abstract, yang const, attribute dan method-nya, semua overide-able).
2. Interface ini, karena dia hanya cangkang, lebih berfungsi untuk (minjem bahasanya Awaludin Rahmadi) blueprint, untuk mendesain API yang tersedia, agar konsisten dan predictable. Abstract di satu sisi, juga merupakan blue-print, tapi karena dia bisa memiliki concrete method, abstract ini potensial untuk re-usabilitas (maka itu seringkali, kita temukan abstract yang mengimplement interface, dan kemudian memiliki definisi default dari method yang di-dikte interface). |
| | | saya cuma mencoba memberi penjelasan dari sisi teknis dengan bahasa yang lebih mudah diterima dan dimengerti.....yang dibilang om Nur , Glend, dan Taufan bener juga kok....baik polimorfisme maupun injector, itu kan tujuan, bukan cara penggunaan.....jadi ya cuma bahas itu aja, dan berusaha tidak menyentuh area lain, biar ga bingung....maklumlah saya kan juga nubi.......hehe |
| | | baca komentarnye berulang2 ama copas codingnye,,, baru ngeh ada kata2 "loose-coupled" di komentarnya mastah glend,,,
* baru ada sedikit bayangan walo msh burem,, |
| | | pertanyaan yang sering muncul adalah kapan anda menggunakan Interface dan Abstract?(seperti di pembahasan lalu)
IMHO, Interface adalah untuk blueprint yang sifatnya sangat mendasar sekali, dan bisa digabungkan dengan Interface lain sehingga menghasilkan Class yang menghasilkan Object yang punya Behaviour gabungan dari beberapa Interface. Contoh ril, misal kita punya blueprint mesin_mobil, pintu_mobil, kap_mobil, bagasi_mobil. Untuk bisa gabungin blueprint2 tersebut, kita bisa menggunakan Interface. Abstract dipergunakan di tahap berikutnya. Biasanya Interface itu isinya bisa sangat banyak method2, sehingga terkadang terlalu sulit langsung menurunkan Method2 tersebut langsung. Disini kita membutuhkan Abstract untuk bisa menjembatani hal tersebut. |
| | | IMHO lagi , pemahaman bahwa interface merupakan 'blueprint' inilah yang memang sering ditulis di buku atau artikel di internet yang sering membuat orang salah kaprah. orang makin bingung fungsi interface, apakah hanya sebagai blueprint ? buat apa ada bluprint , toh tiap class punya juga punya responsibility yang beda. kalo pake cara pandang design pattern, jelas sudah kalo interface maupun abstract digunakan untuk polimorfisme, clear.. :)
Taufan Aditya : dont use abstract to inject behaviour :) karena suatu behaviour bisa dimiliki oleh beberapa tipe object. Use abstract untuk bikin subclass, mungkin contoh penggunaan abstract lebih tepat akan seperti ini :
abstract Ayam
{
/*
OTHER PROPERTY
Other Method
*/
abstract function bertelur();
}
class AyamJantan extends Ayam
{
/*
properti2 termasuk property turunan
method2 termasuk method turunan
*/
public function bertelur()
{
echo 'Ane tidak bisa bertelur';
}
}
class AyamBetina extends Ayam
{
/*
properti2 termasuk property turunan
method2 termasuk method turunan
*/
public function bertelur()
{
echo 'Ane bisa bertelur loh';
}
}
class AmbilTelurDariAyam
{
private Ayam $ayam;
public function __construct(Ayam $ayam)
{
$this->ayam = $ayam;
}
public function ambilTelur()
{
$this->ayam->bertelur();
}
}
client :
Ayam $ayam = new AyamBetina();
AmbilTelurDariAyam $ambilTelur = new AmbilTelurDariAyam($ayam);
$ambilTelur->ambilTelur();
disitu jelas, bahwa AyamJantan dan AyamBetina itu subclass dari Ayam, bukan behaviour, so disini kita pake abstract
CMIIW :) | |
Tidak ada komentar:
Posting Komentar