Belajar Kotlin - Classes, Objects & OOP

#Pendahuluan

Sintaks dasar sudah di tangan. Sekarang episode 4 membangun kemampuan paling penting dalam pengembangan aplikasi: Object-Oriented Programming dengan Kotlin. Kalian akan belajar mendeklarasikan class, membuat constructor dan properties, mengatur visibilitas, serta memakai fitur modern seperti data class dan sealed class.

Kotlin menyederhanakan banyak hal yang bertele-tele di Java: constructor utama langsung di deklarasi class, properties otomatis menghasilkan getter dan setter, dan object keyword menghilangkan pola singleton yang menulis kode manual.

Di akhir episode ini kalian akan bisa merancang domain model yang bersih dan ekspresif — keterampilan yang langsung dipakai di episode 5 sampai 8.

#Class, Constructor, dan Properties

#Constructor Utama dan Properties

Kotlin menggabungkan deklarasi class, constructor, dan properties dalam satu blok. Constructor utama ditulis langsung di kepala class:

Class dengan constructor utama

class Produk(
    val nama: String,
    var harga: Int,
    val stok: Int = 0,
) {
    fun info(): String = "$nama seharga $harga"
}

Parameter val nama dan var harga otomatis menjadi properties dengan getter (dan setter untuk var). stok punya nilai default 0. Untuk memakai class, cukup Produk("Kopi", 15000). Tidak ada lagi method setNama yang bertele-tele. Kalian bisa menguji class ini dengan kotlinc Main.kt -include-runtime -d main.jar lalu menjalankan JAR-nya.

#Init Block dan Secondary Constructor

Logika inisialisasi tambahan ditaruh di blok init, yang dieksekusi saat objek dibuat. Secondary constructor dipakai hanya ketika kalian perlu variasi parameter yang tidak bisa diungkapkan dengan default arguments:

Init block

class Rekening(val pemilik: String) {
    var saldo: Int = 0
    init {
        println("Rekening untuk $pemilik dibuat")
    }
    fun deposit(nominal: Int) {
        saldo += nominal
    }
}

Blok init berjalan setelah properties diinisialisasi. Untuk mayoritas kasus, default arguments sudah cukup — secondary constructor jarang dibutuhkan di Kotlin.

#Visibility Modifiers dan Encapsulation

Kotlin menyediakan empat modifier visibilitas: private, protected, internal, dan public (default). Yang membedakan dari Java adalah internal, yang membatasi akses ke dalam modul yang sama — berguna untuk menyembunyikan API internal library:

Internal dan private

internal class ServiceAktif {
    private val token = "rahasia"
    fun akses(): String = token
}

Modifier private pada property token memastikan hanya class itu sendiri yang bisa mengaksesnya. internal membuat class hanya terlihat di modul yang sama, pola umum pada library yang mengekspos API publik yang bersih.

#Data Classes dan Sealed Classes

#Data Class: Penyimpan Nilai yang Sempurna

data class didesain untuk model data: compiler otomatis menghasilkan equals, hashCode, toString, dan copy berdasarkan properties utamanya:

Data class

data class Pengguna(val id: Int, val nama: String)
 
val a = Pengguna(1, "Budi")
val b = a.copy(nama = "Andi")
println(a) // Pengguna(id=1, nama=Budi)
println(a == Pengguna(1, "Budi")) // true

Method copy memungkinkan membuat salinan dengan sebagian nilai berubah — sangat berguna untuk immutable data. toString yang dihasilkan otomatis membuat debugging data menjadi menyenangkan.

#Sealed Class untuk Hierarki Terbatas

sealed class membatasi subtipe hanya dalam file yang sama, menjadikannya sempurna untuk mewakili state atau hasil yang diketahui. Kombinasi dengan when menghasilkan pemrosesan yang dijamin lengkap oleh compiler:

Sealed class untuk state

sealed class Status {
    data object Loading : Status()
    data class Sukses(val data: String) : Status()
    data class Gagal(val pesan: String) : Status()
}
 
fun tampilkan(s: Status): String = when (s) {
    is Status.Loading -> "Memuat..."
    is Status.Sukses -> "Berhasil: ${s.data}"
    is Status.Gagal -> "Gagal: ${s.pesan}"
}

Karena hierarki Status tertutup, compiler tahu semua kemungkinan — jika suatu saat menambah subtipe baru, kompilasi akan gagal di when sampai kalian menanganinya. Ini salah satu fitur keselamatan favorit di Kotlin.

#Inheritance dan Interface

#Class dan Method Terbuka untuk Pewarisan

Semua class Kotlin bersifat final secara default — pewarisan harus diminta secara eksplisit dengan open. Ini adalah keputusan desain yang mendorong komposisi dan mencegah pewarisan yang tidak disengaja:

Inheritance dengan open

open class Hewan(val nama: String) {
    open fun suara(): String = "Hewan bersuara"
}
 
class Kucing(nama: String) : Hewan(nama) {
    override fun suara(): String = "Meow"
}

open pada class Hewan dan method suara mengizinkan pewarisan dan override. override wajib dituliskan pada method yang menimpa implementasi parent — compiler menegakkan disiplin ini.

#Interface dan Delegation

Interface di Kotlin bisa memiliki implementasi default pada method. Yang lebih menarik, Kotlin mendukung class delegation dengan kata kunci by — menerapkan pola composition tanpa menulis method boilerplate:

Delegation dengan by

interface Logger {
    fun log(pesan: String)
}
 
class ConsoleLogger : Logger {
    override fun log(pesan: String) = println(pesan)
}
 
class Service(private val logger: Logger) : Logger by logger

Service mendelegasikan semua method Logger ke instance logger yang disuntikkan. Kalian tidak perlu menulis ulang implementasi — by menangani delegasinya. Pola ini dipakai untuk dependency injection yang bersih di episode 11.

#Object Declarations dan Companion Objects

#Singleton dengan Object

Kata kunci object mendeklarasikan singleton — satu instance yang dibuat otomatis saat pertama diakses:

Singleton dengan object

object Konfigurasi {
    val versi = "2.1"
    fun info() = "Versi $versi"
}

Konfigurasi.versi dan Konfigurasi.info() dipanggil langsung tanpa membuat instance. Kata kunci object menghilangkan seluruh boilerplate pola singleton: constructor private, static instance, dan getter — semuanya ditangani compiler.

#Companion Object: Anggota Statis yang Aman

companion object menempel pada class dan mirip anggota static di Java, tapi tetap bisa memakai tipe class yang bersangkutan:

Companion object

class Kalkulator {
    companion object {
        fun tambah(a: Int, b: Int): Int = a + b
    }
}
 
val hasil = Kalkulator.tambah(3, 4)

Kalkulator.tambah dipanggil tanpa instance. Companion object berguna untuk factory method dan konstanta yang terikat pada class — pola yang akan kalian lihat di banyak library Kotlin.

#Penutup

Episode 4 membekali kalian dengan OOP modern ala Kotlin: class dengan constructor utama, properties yang otomatis, visibility modifier termasuk internal, data class untuk model data, sealed class untuk hierarki tertutup, inheritance dengan open, interface dengan delegation, serta object dan companion object untuk pola singleton.

Inti yang harus dibawa pulang:

• Constructor utama dan properties dideklarasikan langsung di kepala class.
• Default arguments biasanya cukup; secondary constructor jarang dibutuhkan.
• data class menghasilkan equals, hashCode, toString, dan copy otomatis.
• sealed class menjamin when menangani semua kemungkinan subtipe.
• Class bersifat final secara default; gunakan open untuk membuka pewarisan.
• object membuat singleton; companion object menyediakan anggota statis.

Di episode 5 selanjutnya kita akan membahas collection dan standard library — List, Set, dan Map, operasi koleksi seperti map, filter, fold, dan flatMap, sequences dengan lazy evaluation, serta string manipulation dan utility functions yang membuat pemrosesan data di Kotlin sangat ringkas.