Kotlin Academy · Pelajaran

Kelas Inner

Akses scope luar

Kelas Inner adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Kata Kunci Kelas Dalam

Menandai kelas Nested dengan inner memberinya referensi ke instans kelas luar, sehingga kelas tersebut dapat mengakses anggota kelas luar.

class Outer {
    val msg = "Hello"
    inner class Inner {
        fun show() = msg
    }
}

fun main() {
    println(Outer().Inner().show())
}

Membuat Instans Kelas Dalam

Karena kelas inner memerlukan instans kelas luar, Anda membuatnya dari sebuah instans: Outer().Inner().

class Engine {
    val power = 100
    inner class Turbo {
        fun boosted() = power * 2
    }
}

fun main() {
    println(Engine().Turbo().boosted())
}

Mengakses Properti Kelas Luar

Kelas inner membaca dan menggunakan properti kelas luar secara langsung, seolah-olah properti tersebut adalah miliknya sendiri.

class Counter {
    var count = 0
    inner class Stepper {
        fun step() { count++ }
    }
}

fun main() {
    val c = Counter()
    c.Stepper().step()
    println(c.count)
}

Memanggil Metode Kelas Luar

Kelas inner juga dapat memanggil metode pada instans yang menaunginya.

class Printer {
    fun line(s: String) = println(s)
    inner class Job {
        fun run() = line("printing")
    }
}

fun main() {
    Printer().Job().run()
}

Sintaks untuk Merujuk ke Instans Kelas Luar

Untuk merujuk secara eksplisit ke instans kelas luar, misalnya saat nama bertabrakan, gunakan this@Outer.

class Outer {
    val value = 10
    inner class Inner {
        val value = 20
        fun outerValue() = this@Outer.value
    }
}

fun main() {
    println(Outer().Inner().outerValue())
}

Mengapa Menggunakan Kelas Dalam?

Gunakan inner jika tipe Nested benar-benar perlu bekerja sama dengan instans kelas luar tertentu dan berbagi keadaannya.

class Wallet {
    var balance = 50
    inner class Transaction(val amount: Int) {
        fun apply() { balance += amount }
    }
}

fun main() {
    val w = Wallet()
    w.Transaction(25).apply()
    println(w.balance)
}

Setiap Kelas Dalam Terikat pada Satu Kelas Luar

Sebuah instans inner terikat pada instans kelas luar yang tepat yang membuatnya; perubahan akan diteruskan ke objek tersebut.

class Box(var size: Int) {
    inner class Resizer {
        fun grow() { size += 1 }
    }
}

fun main() {
    val b = Box(3)
    b.Resizer().grow()
    println(b.size)
}

Kelas Dalam vs Kelas Nested

Tanpa inner, kelas Nested terisolasi. Dengan inner, kelas tersebut menangkap instans kelas luar. Kata kunci inilah yang menjadi seluruh perbedaannya.

class Outer {
    val tag = "X"
    inner class A { fun get() = tag }
}

fun main() {
    println(Outer().A().get())
}

Catatan Memori

Karena instans inner membuat instans kelas luar tetap hidup, berhati-hatilah dengan objek inner yang berumur panjang agar tidak mempertahankan objek luar secara tidak sengaja.

class Service {
    val id = 1
    inner class Worker { fun who() = id }
}

fun main() {
    println(Service().Worker().who())
}

Pengiterasi yang Realistis

Kelas inner sangat ideal untuk pengiterasi yang menelusuri keadaan koleksi yang menaunginya.

class Stack {
    private val items = mutableListOf(1, 2, 3)
    inner class Reader {
        fun all() = items.joinToString()
    }
}

fun main() {
    println(Stack().Reader().all())
}

Menggabungkan Konsep

Kelas inner dapat menggunakan keadaan kelas luar dan menghilangkan ambiguitas dengan this@Outer.

class Outer {
    val n = 5
    inner class Inner {
        fun doubled() = this@Outer.n * 2
    }
}

fun main() {
    println(Outer().Inner().doubled())
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang kelas inner.

Rangkuman

Anda telah mempelajari kelas inner:

inner memberikan akses ke instans kelas luar dan anggota-anggotanya.
Buat melalui instans kelas luar: Outer().Inner().
Gunakan this@Outer untuk merujuk ke instans yang menaunginya.
Instans inner membuat instans kelas luarnya tetap hidup.

class Outer {
    val v = 1
    inner class Inner { fun get() = v }
}

fun main() {
    println(Outer().Inner().get())
}

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Kelas Inner” gratis?

Ya — teks lengkap “Kelas Inner” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Kelas Inner”?

Akses scope luar Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Kelas Inner” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Kotlin Academy