Pada artikel ini, Anda akan belajar tentang antarmuka dan cara menerapkannya di Kotlin dengan bantuan contoh.
Antarmuka Kotlin mirip dengan antarmuka di Java 8. Mereka bisa berisi definisi metode abstrak serta implementasi metode non-abstrak. Namun, mereka tidak dapat berisi status apa pun.
Artinya, antarmuka mungkin memiliki properti tetapi harus abstrak atau harus menyediakan implementasi pengakses.
Bacaan yang Direkomendasikan: Kelas Abstrak Kotlin
Kelas abstrak di Kotlin mirip dengan antarmuka dengan satu perbedaan penting. Properti kelas abstrak tidak wajib menjadi abstrak atau menyediakan implementasi pengakses.
Bagaimana cara mendefinisikan antarmuka?
Kata kunci interfacedigunakan untuk mendefinisikan antarmuka di Kotlin. Sebagai contoh,
antarmuka MyInterface (var test: String // properti abstrak fun foo () // metode abstrak fun hello () = "Halo di sana" // metode dengan implementasi default)
Sini,
- antarmuka MyInterface dibuat.
- antarmuka memiliki pengujian properti abstrak dan metode abstrak
foo(). - antarmuka juga memiliki metode non-abstrak
hello().
Bagaimana cara menerapkan antarmuka?
Berikut cara kelas atau objek mengimplementasikan antarmuka:
antarmuka MyInterface (tes val: Int // properti abstrak fun foo (): String // metode abstrak (mengembalikan String) fun hello () (// metode dengan implementasi default // body (opsional))) kelas InterfaceImp: MyInterface (override tes val: Int = 25 override fun foo () = "Lol" // kode lain)
Di sini, kelas InterfaceImp mengimplementasikan antarmuka MyInterface.
Kelas mengganti anggota abstrak (properti dan foo()metode pengujian ) antarmuka.
Contoh: Bagaimana antarmuka bekerja?
interface MyInterface ( val test: Int fun foo() : String fun hello() ( println("Hello there, pal!") ) ) class InterfaceImp : MyInterface ( override val test: Int = 25 override fun foo() = "Lol" ) fun main(args: Array) ( val obj = InterfaceImp() println("test = $(obj.test)") print("Calling hello(): ") obj.hello() print("Calling and printing foo(): ") println(obj.foo()) )
Saat Anda menjalankan program, hasilnya adalah:
test = 25 Memanggil halo (): Halo, sobat! Memanggil dan mencetak foo (): Lol
Seperti disebutkan di atas, sebuah antarmuka mungkin juga memiliki properti yang menyediakan implementasi pengakses. Sebagai contoh,
interface MyInterface ( // property with implementation val prop: Int get() = 23 ) class InterfaceImp : MyInterface ( // class body ) fun main(args: Array) ( val obj = InterfaceImp() println(obj.prop) )
Saat Anda menjalankan program, hasilnya adalah:
23
Di sini, prop bukanlah abstrak. Namun, ini valid di dalam antarmuka karena menyediakan implementasi untuk pengakses.
Namun, Anda tidak dapat melakukan sesuatu seperti val prop: Int = 23di dalam antarmuka.
Menerapkan Dua atau Lebih Antarmuka di Kelas
Kotlin tidak mengizinkan multiple inheritance yang sebenarnya. Namun, dimungkinkan untuk mengimplementasikan dua atau lebih antarmuka dalam satu kelas. Sebagai contoh,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMeToo() ( println("From interface B") ) ) // implements two interfaces A and B class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() obj.callMeToo() )
Saat Anda menjalankan program, hasilnya adalah:
Dari antarmuka A Dari antarmuka B
Menyelesaikan konflik utama (Beberapa Antarmuka)
Misalkan, dua antarmuka (A dan B) memiliki metode non-abstrak dengan nama yang sama (misalkan callMe()metode). Anda mengimplementasikan dua antarmuka ini dalam sebuah kelas (katakanlah C). Sekarang, jika Anda memanggil callMe()metode menggunakan objek kelas C, kompilator akan menampilkan kesalahan. Sebagai contoh,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() )
Inilah kesalahannya:
Kesalahan: (14, 1) Kotlin: Kelas 'C' harus menimpa public open fun callMe (): Unit yang ditentukan di A karena mewarisi beberapa metode antarmuka darinya
Untuk mengatasi masalah ini, Anda perlu menyediakan implementasi Anda sendiri. Begini caranya:
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class C: A, B ( override fun callMe() ( super.callMe() super.callMe() ) ) fun main(args: Array) ( val obj = C() obj.callMe() )
Sekarang ketika Anda menjalankan program, hasilnya adalah:
Dari antarmuka A Dari antarmuka B
Di sini, implementasi eksplisit callMe()metode disediakan di kelas C.
kelas C: A, B (mengesampingkan fun callMe () (super.callMe () super .callMe ()))
Pernyataan tersebut super.callMe()memanggil callMe()metode kelas A. Demikian pula, memanggil metode kelas .super.callMe()callMe()B
