Belajar Kotlin Dari Dasar: Abstract Classes, Interfaces, Inheritance, dan Type Alias

Indonesian (Bahasa Indonesia) translation by Bagus Aji Santoso (you can also view the original English article)

Kotlin adalah sebuah bahasa pemrograman modern yang dikompile menjadi bytecode Java. Bahasa ini tersedia secara gratis dan open source, serta memberikan janji untuk menjadikan koding Android lebih menyenangkan.

Di artikel sebelumnya, kita telah belajar tentang properti Kotlin seperti late-initialization, extention, dan inline properties. Tidak hanya itu, kita juga belajar tentang advanced classes seperti data, enum, nested, dan sealed classes di Kotlin.

Di artikel ini, kita akan melanjutkan pelajaran tentang pemrograman berorientasi objek di Kotlin dengan mempelajari abstract classes, interfaces, dan inheritance. Sebagai bonus, kita juga akan belajar tentang type aliases.

1. Abstract Classes

Kotlin mendukung abstract classes—seperti di Java, mereka adalah kelas yang kita tidak perlu membuat objeknya. Sebuah abstract class adalah kelas yang tidak utuh atau tidak berguna tanpa adanya sublass yang konkrit (non-abstract) yang bisa dipakai untuk membuat objek. Subclass konkrit dari sebuah abstract class mengimplementasi semua method dan properti yang didefinisikan di dalam abstract class—jika tidak maka subclass itu masih termasuk abstract class!

Kita membuat sebuah abstract class dengan modifier abstract (mirip seperti Java)

abstract class Employee (val firstName: String, val lastName: String) {
    abstract fun earnings(): Double
}

Perlu dicatat bahwa tidak semua member harus abstract. Dengan kata lain, kita juga bisa memberikan implementasi default di dalam sebuah abstract class.

abstract class Employee (val firstName: String, val lastName: String) {
    // ... 
    
    fun fullName(): String {
        return lastName + " " + firstName;
    }
}

Di sini kita membuat fungsi non-abstract bernama fullName() di dalam sebuah abstract class Employee. Kelas konkrit (subclass dari abstract class) dapat meng-override implementasi default sebuah method abstract—namun hanya jika method tersebut memiliki modifier open (kita akan mempelajarinya sebentar lagi)

Kita juga dapat menyimpan state di dalam abstract classes.

abstract class Employee (val firstName: String, val lastName: String) {
    // ... 
    val propFoo: String = "bla bla"
}

Meskipun abstract class tidak memiliki method apapun, kita masih perlu membuat sebuah subclass sebelum kita dapat membuat objek, lihat contoh di bawah.

class Programmer(firstName: String, lastName: String) : Employee(firstName, lastName) {

    override fun earnings(): Double {
        // calculate earnings
    }
}

Kelas Programmer kita meng-extends abstract class Employee. Di Kotlin kita menggunakan karakter titik dua (:) bukannya kata kunci extends yang dipakai Java untuk meng-extends sebuah kelas atau mengimplementasi sebuah interface.

Kita dapat membuat sebuah objek dengan tipe Programmer dan memanggil method-nya di objek tadi—baik method kelas itu sendiri maupun superclass-nya (base class).

val programmer = Programmer("Chike", "Mgbemena")
println(programmer.fullName()) // "Mgbemena Chike"

Satu hal yang mungkin dapat mengejutkan pembaca adalah kemampuan untuk meng-override sebuah properti val (immutable) dengan var (mutable).

open class BaseA (open val baseProp: String) {

}

class DerivedA : BaseA("") {

    private var derivedProp: String = ""

    override var baseProp: String
        get() = derivedProp
        set(value) {
            derivedProp = value
        }
}

Pastikan bahwa pembaca menggunakan fungsionalitas ini dengan bijak! Ingat bahwa kita tidak bisa melakukan kebalikannya—meng-override properti sebuah var dengan val.

2. Interfaces

Sebuah interface secara sederhana adalah koleksi dari method yang memberitahu objek apa yang harus dapat ia lakukan dan bagaimana melakukannya. (Default method di interface merupakan fitur baru yang ditambahkan ke Java 8.) Dengan kata lain, sebuah interface merupakan kontrak yang harus diimplementasi oleh kelas yang mengimplementasinya.

Sebuah interface dibuat dengan menggunakan kata kunci interface di Kotlin (mirip dengan Java).

class Result
class Student 

interface StudentRepository {
    fun getById(id: Long): Student
    fun getResultsById(id: Long): List<Result>
}

Pada kode di atas, kita mendeklarasikan sebuah interface StudentRepository. Interface ini memiliki dua method abstract: getById() dan getResultsById(). Perlu dicatat bahwa penggunakan kata kunci abstract di sebuah interface adalah redundan karena mereka secara implisit sudah merupakan sebuah kelas abstract.

Sebuah interface tidak berguna tanpa sebuah kelas yang mengimplementasinya—jadi sekarang mari kita buah sebuah kelas yang akan mengimplementasi interface ini.

class StudentLocalDataSource : StudentRepository {
    override fun getResults(id: Long): List<Result> {
       // do implementation
    }

    override fun getById(id: Long): Student {
        // do implementation
    }
}

Di sini kita membuat sebuah kelas StudentLocalDataSource yang mengimplement interface StudentRepository.

Kita gunakan modifier override untuk menandai method dan properti yang ingin dibuat ulang dari sebuah interface atau superclass—mirip seperti anotasi @Override di Java.

Ingat aturan-aturan tambahan berikut untuk interface in Kotlin:

Sebuah kelas dapat mengimplementasi interface sebanyak-banyaknya, tapi ia hanya bisa meng-extend satu kelas (mirip dengan Java).
Modifier override wajib ditambahkan di Kotlin—tidak seperti di Java.
Seperti method, kita juga dapat mendeklarasikan properti di interface Kotlin.
Method di interface Kotlin dapat memiliki implementasi bawaan (seperti Java 8).

Mari kita lihat sebuah contoh dari method interface dengan sebuah implementasi bawaan.

interface StudentRepository {
    // ... 
    fun delete(student: Student) {
        // do implementation
    }
}

Pada kode di atas, kita menambahkan sebuah method baru delete() dengan sebuah implementasi bawaan (meskipun saya tidak menulis apapun karena hanya sebagai contoh).

Kita juga memiliki kebebasan untuk meng-override implementasi bawaan jika mau.

class StudentLocalDataSource : StudentRepository {
    // ... 
    override fun delete(student: Student) {
       // do implementation
    }
}

Seperti yang sudah dijelaskan, interface Kotlin dapat memiliki properti—namun catat bahwa ia tidak bisa menyimpan suatu nilai. (Meski begitu, ingat bahwa abstract classes bisa menyimpan nilai.) Jadi pembuatan interface berikut dengan sebuah properti akan bekerja.

interface StudentRepository {
    val propFoo: Boolean // will work
    // ... 
}

Namun apabila kita mencoba menambah suatu nilai pada properti tersebut, interface itu tidak akan bekerja.

interface StudentRepository {
    val propFoo: Boolean = true // Error: Property initializers are not allowed in interfaces
    // .. 
}

Namun, sebuah properti interface di KOtlin dapat memiliki getter and setter (meskipun nanti bila properti tersebut mutable). Catat juga bahwa properti di dalam sebuah interface tidak dapat memiliki sebuah backing field.

interface StudentRepository {
    var propFoo: Boolean
        get() = true
        set(value)  {
           if (value) {
             // do something
           }
        }
    // ...
}

Kita juga dapat meng-override sebuah properti interface jika mau.

class StudentLocalDataSource : StudentRepository {
    // ... 
    override var propFoo: Boolean
        get() = false
        set(value) {
            if (value) {
                
            }
        }
}

Mari kita lihat kasus di mana kita memiliki sebuah kelas yang mengimplementasi beberapa interface dengan nama method yang sama. Bagaimana kelas tersebut menentukan method milik interface mana yang akan dipanggil?

interface InterfaceA {
    fun funD() {}
}

interface InterfaceB {
    fun funD() {}
}

Di sini kita memiliki dua interface yang memiliki sebuah methode dengan nama sama funD(). Mari kita buat sebuah kelas yang mengimplementasi dua interface ini dan meng-override method funD().

class classA : InterfaceA, InterfaceB {
    override fun funD() {
        super.funD() // Error: Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super<Foo>'
    }
}

Kompiler akan bingung saat memanggil super.funD() karena ada dua interface yang diimplementasi di dalam kelas yang sama dan memiliki nama method yang sama.

Untuk menyelesaikan masalah ini, kita membungkus nama interface yang methodnya ingin kita panggil ke dalam kurung sudut <InterfaceName>. (IntelliJ IDEA atau Android Studio akan memberitahu cara menyelesaikan permasalahan ini).

class classA : InterfaceA, InterfaceB {
    override fun funD() {
        super<InterfaceA>.funD()
    }
}

Di atas kita akan memanggil method funD() milik InterfaceA. Masalah selesai!

3. Pewarisan

Sebuah kelas baru (subclass) dibuat dengan mengambil isi kelas super dan mungkin mendefinisikan ulang implementasi bawaannya. Mekanisme ini dikenal dengan istilah pewarisan dalam konsep pemrograman berorientasi objek (PBO).

Base class untuk semua kelas di Kotlin adalah Any.

class Person : Any {
}

Kelas Any mirip dengan Object yang ada di Java.

public open class Any {
    public open operator fun equals(other: Any?): Boolean
    public open fun hashCode(): Int
    public open fun toString(): String
}

Kelas Any memiliki beberapa method berikut: equals(), hashcode(), dan toString() (mirip dengan di Java).

Kelas kita tidak perlu secara eksplisit meng-extend Any. Jika tidak secara eksplisit menentukan sebuah kelas meng-extend kelas apa, maka secara implisit ia akan meng-extend Any. Untuk alasan ini, Anda biasanya tidak perlu menambahkan : Any di kode yang ditulis—kita menulisnya di atas hanya untuk contoh.

Mari kita buat kelas-kelas di Kotlin untuk membahas pewarisan.

class Student {

}

class GraduateStudent : Student() {

}

Pada kode di atas kelas GraduateStudent meng-extend superclass Student. Tapi kode ini tidak akan berjalan. Mengapa? Karena kelas dan method bernilai final secara otomatis di Kotlin. Dengan kata lain, mereka secara otomatis tidak bisa di extend—berbeda dengan Java di mana kelas dan method sudah terbuka secara otomatis.

Para ahli menganjurkan untuk membuat kelas dan method final secara otomatis—artinya jika mereka tidak secara khusus perlu di extend atau di override oleh subclass. Tim pengembang Kotlin (JetBrains) mengaplikasikan filosofi ini dan banyak best practice lain dalam mengembangkannya.

Agar kita bisa membuat sebuah subclass dari sebuah superclass, maka kita perlu secara eksplisit menandari superclass dengan modifier open. Modifier ini juga berlaku pada semua properti superclass atau method yang dapat di override oleh subclass.

open class Student {

}

Kita dapat mengubah modifier open sebelum kata kunci class. Kita sekarang sudah menginstruksikan kompiler untuk memerbolehkan kelas Student untuk di extend oleh kelas lain.

Seperti yang sudah dijelaskan, anggota sebuah kelas Kotlin juga final secara otomatis.

open class Student {
    
    open fun schoolFees(): BigDecimal {
       // do implementation
    }
}

Pada kode di atas, kita menandai fungsi schoolFees sebagai open—dengan begitu subclass dapat meng-override-nya.

open class GraduateStudent : Student() {

    override fun schoolFees(): BigDecimal {
        return super.schoolFees() + calculateSchoolFees()
    }

    private fun calculateSchoolFees(): BigDecimal {
        // calculate and return school fees
    }
}

Di sini, fungsi schoolFees yang sudah dibuka dari superclass Student di-override oleh kelas GraduateStudent—dengan menambahkan modifier override sebelum kata kunci fun. Catat bahwa jika Anda meng-override sebuah anggota dari superclass atau interface, member yang meng-override-nya juga akan menjadi open secara otomatis seperti pada contoh berikut:

class ComputerScienceStudent : GraduateStudent() {

    override fun schoolFees(): BigDecimal {
        return super.schoolFees() + calculateSchoolFess()
    }

    private fun calculateSchoolFess(): BigDecimal {
        // calculate and return school fees
    }
}

Meskipun kita tidak menandai method schoolFees() di dalam kelas GraduateStudent dengan modifier open, kita masih dapat meng-override-nya—seperti yang kita lakukan pada kelas ComputerScienceStudent. Jika ingin mencegah hal ini, kita harus menandai member tadi dengan kata kunci final.

Ingat bahwa kita bisa menambah fungsionalitas ke dalam sebuah kelas—meskipun dideklarasikan final—menggunakan extensino functino milik Kotlin. Untuk mengingat lagi apa itu extention function, kunjungi artikel Advanced Functions in Kotlin. Lalu, jika Anda memerlukan pengingat tentang bagaimana memberikan sebuah kelas final properti baru tanpa meng-extend-nya, baca pembahasan extentions Properties di Advanced Properties and Classes saya.

Jika superclass kita memiliki konstruktor utama seperti ini:

open class Student(val firstName: String, val lastName: String) {
    // ... 
}

Maka semua subclass harus memanggil konstruktor utama miliki superclass.

open class GraduateStudent(firstName: String, lastName: String) : Student(firstName, lastName) {
    // ... 
}

Kita dapat membuat objek dari kelas GraduteStudent seperti biasa.

val graduateStudent = GraduateStudent("Jon", "Snow")
println(graduateStudent.firstName) // Jon

Jika subclass ingin memanggil konstruktor superclass dari konstruktor keduanya, kita gunakan kata kunci super (mirip dengan cara kerja konstruktor superclass di Java).

open class GraduateStudent : Student {
    // ...
    private var thesis: String = ""
    
    constructor(firstName: String, lastName: String, thesis: String) : super(firstName, lastName) {
        this.thesis = thesis
    }
}

Jika Anda perlu mengingat konstruktor di Kotlin, silahkan baca artikel Classes and Objects saya.

4. Bonus: Type Alias

Hal keren lain yang bisa dilakukan di Kotlin adalah memberikan sebuah alias.

Lihat contoh berikut.

data class Person(val firstName: String, val lastName: String, val age: Int)

Pada contoh di atas kita memberikan alias untuk String dan Int di properti milik Person dengan modifier typealias di Kotlin. Modifier ini dipakai untuk membuat sebuah alias dari semua jenis tipe data di Kotin—termasuk yang baru saja kita buat.

typealias Name = String
typealias Age = Int

data class Person(val firstName: Name, val lastName: Name, val age: Age)

Seperti yang dapat Anda lihat, kita membuat sebuah alias Name dan Age untuk tipe String dan Int. Kita sekarang dapat menimpa firstName dan lastName menggunakan tipe data alias Name—juga Int untuk tipe Age. Catat bahwa kita tidak membuat tipe data baru—kita hanya membuat alias atau nama lain dari sebuah tipe data.

Opsi ini sangat berguna untuk memberikan pemaknaan atau semantik untuk kode Kotlin. Jadi gunakna dengan bijak!

Kesimpulan

Di tutorial ini, Anda telah belajar tentang pemrograman berorientasi objek di Kotlin. Kita telah membahas:

abstract classes
interfaces
inheritance
type alias

Jika Anda sudah belajar melalui seri Kotlin From Scratch kami, pastikan untuk menuliskan kode yang dilihat dan menjalankannya ke dalam IDE. Satu tips ini sangat baik untuk dilakukan saat belajar bahasa pemrograman baru (atau konsep pemrograman manapun) yaitu pastikan untuk tidak sekedar membaca suatu tutorial, tapi menuliskan dan menjalankannya!

Tutorial selanjutnya di seri Kotlin From Scratch kita akan belajar menggunakan exception handling di Kotlin. Sampai jumpa lagi!

Untuk mempelajari bahasa Kotlin lebih lanjut, saya merekomendasikan Anda untuk mengunjungi dokumentasi Kotlin. Atau periksa beberapa post pembuatan aplikasi Android di sini di Envato Tuts!