Dalam dunia pemograman berbasis objek, Interface adalah semacam kontrak, dimana kita bisa memastikan bahwa kelas-kelas yang mengimplementasikan interface pasti memiliki semua method yang kita deklarasikan di dalam interface. Jadi secara konsep mirip dengan abstract method yang kita pelajari pada video sebelumnya.

Apa perbedaan antara abstract method dengan interface? Kapan kita menggunakan abstract dan kapan kita menggunakan interface. Nah, kalau kita ingat kembali ke pelajaran sebelumnya, pada saat kita hendak menggunakan abstract, maka kita harus membuat kelas. Dan pada saat kita hendak menggunakannya, kita harus membuat kelas turunan dari abstract class. Disini kita dibatasi oleh aturan Inheritance, dimana kelas anak hanya bisa diturunkan dari satu kelas induk.

Kalau kita menginginkan cara coding yang lebih flexible, maka lebih cocok menggunakan Interface. Pada saat kita hendak menggunakan interface, kita bisa membuat class dan menambahkan kata kunci implements. Kelas yang sama bisa mengimplementasikan lebih dari satu interface, dan kelas tersebut masih bisa kita turunkan dari kelas yang lain.

Jadi dari sisi penggunaan, untuk sebagaian besar kasus kita lebih cocok menggunakan interface. Abstract hanya cocok digunakan untuk kelas induk yang tidak boleh di-instantiate menjadi sebuah objek.

Yang menjadi kekurangan dari interface adalah interface tidak boleh mengandung property. Namun interface boleh mengandung konstan.

Berikut adalah contoh kode interface. Untuk menggunakan interface, pertama kita sebutkan dahulu kata kuncinya yaitu interface diikut oleh nama interface-nya. Penamaan Interface biasanya menggunakan PascalCase seperti nama kelas. Apabila nama interface terdiri dari beberapa kata, maka setiap huruf pertama dari setiap kata menggunakan huruf besar. Dan untuk penamaan di bahasa pemograman PHP, biasanya di bagian paling belakang nama ditambahkan dengan kata Interface.

Dalam contoh ini kita membuat interface dengan nama RunnableInterface. Runnable berarti bisa lari, maka di dalamnya terdapat method run atau lari. Method di dalam interface hanya dalam bentuk deklarasi saja, tidak ada implementasinya.

Kemudian kita membuat kelas Dog yang mengimplementasikan RunnableInterface. Perhatikan setelah kita mendeklarasikan nama kelas Dog, kita tambahkan kata implements dan diikuti oleh nama Interface-nya. Di dalam kelas, kita harus menuliskan kode implementasi dari method run.

Agar lebih jelas kita coba praktek ya. Kita buka kembali Visual Studio Code dan kita buat file baru dengan nama interface.php. Namun sebelum melanjutkan saya disklaimer dahulu ya. Dalam proyek aslinya, sebaiknya teman-teman memisahkan kode dalam video ini menjadi beberapa file. Interface dalam file tersendiri. Kelas dalam file tersendiri. Dan kemudian ada file utama yang require file Interface dan Class untuk dijalankan. Dan untuk praktek yang lebih baiknya lagi, kita mesti menggunakan Namespace. Namun untuk menyederhanakan contoh dalam video ini, semua kode saya gabung menjadi satu file.

Pertama kita buat dahulu tag pembuka PHP. Kemudian kita mulai dengan membuat interface. Kita ketik kata kunci interface diikuti oleh nama Interface-nya yaitu RunnableInterface lalu kurung kurawal. Di dalam blok, kita tuliskan deklarasi semua method yang dimiliki oleh interface ini. Dalam contoh ini kita hanya membuat satu method saja ya. Kita ketik public function run(): void.

Kita coba jalankan dulu kodenya ya. Tidak ada error. Nah, yang perlu kita ingat pada interface adalah kita hanya bisa menggunakan visibility public. Jadi kalau misalkan disini kita ganti menjadi private, maka kita mendapatkan error. Begitu juga kalau kita ganti dengan protected. Jadi visibility yang digunakan pada interface haruslah public.

Selanjutnya kita buat kelas yang mengimplementasikan RunnableInterface. Kita buat kelas dengan nama Dog. Kemudian untuk menggunakan interface, kita menggunakan kata kunci implements diikuti oleh namanya yaitu RunnableInterface. Kemudian kita tambahkan tanda kurung kurawal.

Sampai disini, kalau kodenya langsung kita jalankan maka kita mendapatkan fatal error ya. Karena Interface ini adalah semacam kontrak, dimana kalau kita menggunakan Interface, maka kita harus menuliskan kode implementasi untuk semua method yang ada di dalam interface. Kebetulan pada RunnableInterface hanya terdapat satu method run.

Jadi di dalam blok kelas, kita harus tambahkan method run, yang deklarasinya harus sama persis dengan deklarasi pada RunnableInterface. Method tidak menggunakan parameter dan mengembalikan nilai void. Di dalamnya, kita coba saja contoh sederhana misalkan kita echo "Dog is running\n".

Kita jalankan. Sudah tidak error tapi tidak terjadi apa-apa ya. Karena kita belum menuliskan kode untuk memanggil method-nya.

Kita tambahkan kode baru. Pertama kita buat variable $dog untuk melakukan instantiate terhadap kelas Dog. Setelah itu kita panggil method $dog->run(). Dan kita mendapatkan hasil Dog is running.

Mirip dengan abstract method, kegunaan dari Interface berkaitan dengan Polymorphism. Misalkan kita buat function callRun dengan parameter berupa RunnableInterface. Kemudian di dalamnya kita bisa memanggil method run. Disini kita bisa memastikan bahwa kita aman dari error, karena semua objek yang dikirim sebagai parameter sudah pasti memiliki method run.

Setelah kita membuat objek dog, maka kita bisa menggunakannya sebagai argument untuk memanggil fungsi callRun. Berhubung kelas Dog mengimplementasi RunnableInterface, maka disini terjadi polymorphism sehingga Dog bisa berubah bentuk menjadi RunnableInterface. Kalau kode kita jalankan, tidak terjadi error dan hasilnya tetap sama.

Kita buat contoh lain ya. Misalkan kelas Dog kita copy paste menjadi kelas Cat. Dan isi method run kita ganti menjadi Cat is running. Kemudian kita buat instantiate dari kelas Cat. Dan kita gunakan sebagai argument untuk memanggil callRun. Maka kita mendapatkan hasil pertama "Dog is running" dari kode lama, dilanjutkan dengan "Cat is running" dari kode baru. Jadi kelas apa pun yang mengimplementasikan RunnableInterface, bisa kita gunakan sebagai argument untuk memanggil fungsi callRun.

Selanjutnya kita coba beberapa hal yang menarik dari interface. Yang pertama kita perhatikan pada saat kita membuat kelas Dog. Berhubung kita menggunakan kata kunci implements untuk Interface, maka kita masih bisa menggunakan kata kunci extends untuk menjadi turunan dari kelas lainnya. Sebagai contoh kita buat kelas Pet yang isinya hanya satu property $name. Kemudian pada deklarasi kelas Dog, kita bisa tambahkan extends Pet. Begitu juga pada deklarasi kelas Cat.

Kita coba jalankan. Tidak terjadi error ya. Kalau kita coba var_dump object $dog. Kita bisa menemukan pada object terdapat property $name, walaupun nilainya belum diinisialisasi.

Hal kedua yang menarik adalah kita bisa membuat lebih dari satu interface dan mengimplementasikannya pada kelas yang sama. Kita buat contohnya ya. Kita buat interface baru yaitu PetTypeInterface. Isinya adalah satu buah method dengan nama getType, tanpa parameter dan mengembalikan integer.

Sayangnya Interface tidak boleh mengandung property ya. Jadi kalau misalkan pada interface baru ini kita tambahkan property dengan tipe data int misalkan namanya $type, maka kita mendapatkan error. Namun walaupun interface tidak boleh mengandung property, interface tetap boleh mengandung konstanta. Misalkan kita ingin memberikan arti terhadap nilai yang dikembalikan pada method getType ini ya. Misalkan nilai 1 berarti mamalia, nilai 2 berarti reptil, dan seterusnya.

Untuk itu kita bisa menggunakan konstanta. Sebagai contoh. Kita tambahkan public const PET_TYPE_MAMALS dengan nilai 1. Kemudian PET_TYPE_REPTILE dengan nilai 2 dan PET_TYPE_FISH dengan nilai 3. Kita simpan dan kalau kita coba jalankan maka tidak terjadi error.

Kita coba implementasikan pada kelas Dog. Untuk menambahkan interface selanjutnya, kita tinggal tambahkan tanda koma setelah RunnableInterface lalu diikuti dengan nama PetTypeInterface. Kita simpan dan jalankan. Dan sekarang kita mendapatkan fatal error ya. Karena kita menggunakan PetTypeInterface namun kita tidak membuat implementasi dari method getType.

Sekarang kita tambahkan method getType. Berhubung anjing adalah mamalia, maka seharusnya kita mengembalikan nilai konstanta PET_TYPE_MAMALS. Ingat lagi ya, untuk mengakses konstanta maka kita menggunakan kata kunci self diikuti oleh dua buah tanda titik dua. Setelah itu barulah kita sebutkan nama konstantanya. Kemudian pada fungsi var_dump kita ganti argumentnya menjadi memanggil method getType. Dan kita mendapatkan hasil integer 1.

Kalau kita hendak mengakses nilai konstanta diluar dari kelas, maka kita bisa menggunakan nama Interface-nya yaitu PetTypeInterafce, diikuti oleh dua buah tanda titik dua dan nama konstantanya misalkan PET_TYPE_MAMALS. Dan kita mendapatkan hasil nilai 1.

Atau sebagai alternatifnya, kita bisa menggunakan nama kelas yang mengimplementasikan interface tersebut. Misalkan pada contoh kita adalah kelas Dog. Maka kita mendapatkan hasil yang sama yaitu 1.

Kita lanjutkan materi kita. Kita bisa membuat turunan dari Interface dengan menggunakan kata kunci extends. Apabila kita membuat kelas yang mengimplementasikan interface turunan, maka kita harus menuliskan kode implementasi untuk semua method yang didelarasikan pada interface turunan dan interface induknya.

Pada waktu kita belajar inheritance pada kelas, kita diberitahukan bahwa ada aturan bahwa setiap kelas anak hanya boleh memiliki 1 kelas induk. Namun hal ini tidak berlaku untuk Interface. Interface bisa dibuat dari banyak induk sekaligus. Setelah kata kunci extends, kita bisa menuliskan beberapa nama interface induk dengan dipisahkan oleh tanda koma.

Ini adalah contoh kode dari Interface Inheritace. Pertama kita buat dahulu RunnableInterface yang memiliki method run. Kemudian kita buat lagi HasLegsInterface yang merupakan turunan dari RunnableInterface. Disini kita buat method baru yaitu getLegs untuk mengambil jumlah kakinya.Nah, pada saat kita membuat kelas Dog yang mengimplementasikan HasLegsInterface, maka kita harus menuliskan kode implementasi untuk semua method milik HasLegsInterface dan semua method milik induknya. Artinya kelas Dog harus punya method run dan getLegs.

Kita coba praktek. Kita buka kembali kode yang barusan. Kita tambahkan dahulu interface baru HasLegsInterface yang kita extends dari RunnableInterface. Di dalamnya kita deklarasikan method getLegs tanpa parameter yang mengembalikan nilai int. Kalau kita coba jalankan, tidak ada error ya.

Kita lihat kembali ke kode kelas Dog. Disini masih mengimplementasikan RunnableInterface. Kita ganti ya. Menjadi HasLegsInterface. Kalau kita coba jalankan, sekarang kode kita sudah mengalami error ya. Disebabkan karena kelas Dog tidak menuliskan kode implementasi untuk method getLegs.

Kita tambahkan method getLegs tanpa parameter yang mengembalikan nilai int. Kita langsung saja return angka 4. Kalau kita jalankan maka sudah tidak error.

Nah, yang perlu diperhatikan disini adalah berhubung HasLegsInterface adalah turunan dari RunnableInterface. Kalau kita ingin mengimplementasikan HasLegsInterface, maka kita harus menuliskan kode implementasi untuk semua method milik HasLegsInterface dan semua method milik RunnableInterface. Method milik RunnableInterface adalah run. Jika method ini kita coba hapus dari kelas Dog, maka kita mendapatkan fatal error. Kita kembalikan dulu agar tidak error ya.

Kemudian yang menariknya lagi, ternyata kita bisa menurunkan Interface dari banyak parent sekaligus. Sebagai contoh disini ada satu interface lagi yaitu PetTypeInterface ya. Pada deklarasi HasLegsInterface kita tambahkan menjadi entends RunnableInterface, PetTypeInterface. Artinya HasLegsInterface memiliki 2 parent yaitu RunnableInterface dan PetTypeInterface. Apabila kelas dog mengimplementasikan satu interface saja HasLegsInterface, maka kelas dog harus menuliskan kode implementasi untuk ketiga interface yang ada. Kalau misalkan method getType kita hapus, maka kita mendapatkan fatal error.

Dengan menggunakan fasilitas tanya jawab, maka Anda bisa bertanya dan akan dijawab langsung oleh instruktur kursus.

Anda belum terdaftar pada kursus ini sehingga tidak bisa mengajukan pertanyaan.