Trik Memahami Casting Java Interface

Trik Memahami Casting Java Interface

ilustrasi casting java object

Dalam bahasa pemrograman Java kita mengenal interface. Secara sederhana yang dimaksud dengan interface adalah antar muka yang berisi cetakan fungsi-fungsi yang nantinya harus diimplementasikan oleh class yang memakai interface tersebut.

Artikel ini adalah lanjutan dari dua artikel sebelumnya, Cara Mudah Memahami Java Casting dan Trik Memahami Casting Java Object. Kalau pada artikel pertama kita membahas casting menggunakan tipe data primitive dan pada artikel kedua kita membahas casting pada tipe data class non primitive, maka pada artikel ini kita akan membahas casting antara class dengan interface dan interface dengan interface. Sebaiknya Anda membaca dulu dua artikel sebelumnya agar lebih memahami artikel ini.

Untuk lebih memudahkan memahami konsep interface (bagian dari konsep OOP) pada Java, Nextgen menyediakan kursus java. Metode kursus Nextgen sangat fokus kepada tugas dan pengerjaan coding sehingga membantu pesertanya menjadi lebih mengerti dan paham tentang konsep interface dan OOP.

Secara garis besar casting dengan menggunakan interface terbagi menjadi tiga kasus yang akan kita jelaskan satu persatu.

Casting Antar Interface

Setiap object bisa dideklarasikan melalui sebuah variabel yang bertipe interface. Syaratnya class dari object tersebut harus implement interface yang dimaksud. Casting antar interface adalah mengubah tipe interface variabel object tertentu kepada variabel lain dengan tipe interface yang berbeda. Seperti juga pada kasus casting yang lain, casting inipun dibagi menjadi dua kasus yaitu automatic casting dan manual casting.

Automatic Casting Antar Interface

Kasus ini terjadi apabila tipe interface pada variabel lama sudah pasti juga merupakan tipe interface pada variabel baru. Perhatikan contoh berikut.

// deklarasi interface
interface IBinatang {}
interface IKuda extends IBinatang {}
// deklarasi class
class Binatang implements IBinatang {}
class Kuda extends Binatang implements IKuda {}
// membuat object Kuda dengan variabel tipe IKuda
IKuda kuda = new Kuda();
// Automatic casting ke variabel tipe IBinatang
IBinatang binatang = kuda;

Disini automatic casting dapat dipakai karena Kuda sudah pasti juga merupakan Binatang. Karena itu juga interface IKuda mempunyai super interface IBinatang. Contoh kasus seperti ini akan cukup banyak kita temukan dalam pemrograman Java, karena dalam memakai library-library pihak ketiga kita akan menemukan banyak sekali object yang dideklarasikan dalam variabel berbentuk interface.

Manual Casting Antar Interface

Kasus ini terjadi apabila tipe interface pada variabel lama belum tentu juga merupakan tipe interface pada variabel baru. Perhatikan contoh berikut ini.

// deklarasi interface
interface IBinatang {}
interface IKuda extends IBinatang {}
// deklarasi class
class Binatang implements IBinatang {}
class Kuda extends Binatang implements IKuda {}
// membuat object Binatang dengan variabel tipe IBinatang
IBinatang binatang = new Binatang();
// Manual casting ke variabel tipe IKuda
IKuda kuda = (IKuda) binatang;

Dalam contoh kasus diatas, object Binatang belum tentu juga merupakan Kuda, karena bisa jadi object tersebut adalah Kerbau. Karena itulah dalam contoh diatas kita memerlukan manual casting. Sama juga seperti manual casting pada object, bisa terjadi dua kemungkinan, pertama casting berhasil dan kedua casting gagal dan melemparkan ClassCastException pada saat Runtime.

Casting Class Ke Interface

Pada dasarnya konsepnya sama seperti casting antar interface dan casting antar class. Perhatikan contoh automatic casting dibawah ini.

// deklarasi interface
interface IBinatang {}
interface IKuda extends IBinatang {}
// deklarasi class
class Binatang implements IBinatang {}
class Kuda extends Binatang implements IKuda {}
// membuat object Kuda dengan variabel tipe Kuda
Kuda kuda = new Kuda();
// Automatic casting ke variabel tipe IBinatang
IBinatang binatang = kuda;

Pada contoh diatas kita sudah tahu bahwa Kuda adalah juga merupakan Binatang, oleh karena itu kita bisa melakukan automatic casting. Bedanya dengan contoh sebelumnya adalah, variabel kuda dideklarasikan dalam bentuk class Kuda dan kita casting kedalam variabel binatang yang dideklarasikan dalam bentuk interface IBinatang. Sekarang mari kita lihat contoh manual casting.

// deklarasi interface
interface IBinatang {}
interface IKuda extends IBinatang {}
// deklarasi class
class Binatang implements IBinatang {}
class Kuda extends Binatang implements IKuda {}
// membuat object Binatang dengan variabel tipe Binatang
Binatang binatang = new Binatang();
// Manual casting ke variabel tipe IKuda
IKuda kuda = (IKuda) binatang;

Karena tidak semua Binatang merupakan Kuda maka kita perlu melakukan manual casting. Seperti contoh pada automatic casting, kita melakukan casting dari variabel bertipe class kepada variabel bertipe interface.

Casting Interface Ke Class

Contoh kasus ketiga adalah casting dari variabel bertipe interface kepada variabel bertipe class. Mari kita lihat contoh automatic casting.

// deklarasi interface
interface IBinatang {}
interface IKuda extends IBinatang {}
// deklarasi class
class Binatang implements IBinatang {}
class Kuda extends Binatang implements IKuda {}
// membuat object Kuda dengan variabel tipe IKuda
IKuda kuda = new Kuda();
// Automatic casting ke variabel tipe Binatang
Binatang binatang = kuda;

Karena kita tahu bahwa Kuda sudah pasti juga merupakan Binatang maka kita dapat melakukan automatic casting. Dalam contoh diatas terlihat kita melakukan casting dari variabel bertipe interface yaitu IKuda kepada variabel bertipe class yaitu Binatang. Bisa ditebak contoh berikutnya untuk manual casting.

// deklarasi interface
interface IBinatang {}
interface IKuda extends IBinatang {}
// deklarasi class
class Binatang implements IBinatang {}
class Kuda extends Binatang implements IKuda {}
// membuat object Binatang dengan variabel tipe IBinatang
IBinatang binatang = new Binatang();
// Manual casting ke variabel tipe Kuda
Kuda kuda = (Kuda) binatang;

Karena tidak semua Binatang merupakan Kuda maka kita harus melakukan manual casting. Manual casting yang kita lakukan adalah dari variabel bertipe interface (IBinatang) kepada variabel bertipe class (Kuda). Sama seperti manual casting lainnya, cara ini bisa menyebabkan ClassCastException.

Sekian dulu artikel yang membahas casting interface dan class, topik ini memang agak sedikit rumit karena untuk memahaminya kita juga harus memahami OOP secara mendalam.

Tentang Penulis

Tinggalkan Balasan

Keranjang Belanja0
Keranjang belanja kosong ...
0