Tutorial Kotlin 40 : Cara Membuat Inner Nested Class pada Kotlin

Last Updated on April 25, 2023 by

Dalam pemrograman Kotlin, terdapat konsep yaitu inner nested class yang terdiri dari kelas bersarang (nested class) dan kelas dalam (inner class) yang memungkinkan kita untuk menyisipkan dan menyimpan satu kelas di dalam kelas lain. Konsep ini membantu dalam mengelompokkan fungsionalitas yang terkait dan meningkatkan enkapsulasi serta pengorganisasian kode yang lebih baik. 

Seri belajar Kotlin kali ini akan membahas konsep inner nested class pada bahasa pemrograman Kotlin, cara mengakses properti dan fungsi anggota, serta membandingkan konsep ini dengan Java. Selain itu, kita juga akan mengeksplorasi kelebihan dan kekurangan penggunaan kelas bersarang dan kelas dalam dalam kode Kotlin. Yuk simak selengkapnya pada ulasan berikut ini!

Kotlin Nested Class

Dalam bahasa pemrograman Kotlin, Anda dapat mendefinisikan suatu kelas di dalam kelas lain, yang dikenal sebagai kelas bersarang atau nested class. Kelas bersarang merupakan kelas yang memiliki akses ke anggota (field dan metode) dari kelas luar atau kelas lainnya. Berikut adalah contoh kelas bersarang dalam Kotlin.

class Mobil {
    var merek: String = ""
    var model: String = ""
    var tahun: Int = 0
   
    inner class Mesin {
        var tenagaKuda: Int = 0
        var silinder: Int = 0

        fun infoMesin(): String {
            return "$tenagaKuda tenaga kuda, $silinder silinder, dalam $merek $model"
        }
    }

    fun info(): String {
        return "$merek $model, tahun $tahun"
    }
}

fun main() {
    val mobilSaya = Mobil()
    mobilSaya.merek = "Toyota"
    mobilSaya.model = "Camry"
    mobilSaya.tahun = 2020

    val mesin = mobilSaya.Mesin()
    mesin.tenagaKuda = 250
    mesin.silinder = 6
   
    println(mesin.infoMesin())
}

Output:

250 tenaga kuda, 6 silinder, dalam Toyota Camry

Ketika suatu kelas dapat dideklarasikan dalam kelas lain maka disebut dengan kelas bersarang (nested class). Secara default kelas bersarang adalah statis sehingga kita dapat mengakses properti atau variabel kelas bersarang menggunakan notasi titik (.) tanpa membuat objek kelasnya. Berikut adalah contoh sintaks deklarasi untuk kelas bersarang atau nested class.

class KelasLuar {
      ............
      // properti atau fungsi anggota kelas luar
     
      class KelasBersarang {
            ..........
            // properti atau fungsi anggota kelas dalam
      }
}

Program Kotlin untuk mengakses properti Nested Class

// deklarasi kelas luar 

class KelasLuar { 

    var str = "Kelas luar" 

    // deklarasi kelas bersarang 

    class KelasBersarang { 

        val namaDepan = "Praveen" 

        val namaBelakang = "Ruhil" 

    } 

} 

fun main(args: Array<String>) { 

    // mengakses anggota KelasBersarang 

    print(KelasLuar.KelasBersarang().namaDepan) 

    print(" ") 

    println(KelasLuar.KelasBersarang().namaBelakang) 

}

Output:

Praveen Ruhil

Program Kotlin untuk mengakses fungsi anggota Nested Class

Pada bahasa pemrograman Kotlin, untuk mengakses fungsi anggota kelas bersarang, kita perlu membuat objek untuk kelas bersarang dan memanggil fungsi anggota menggunakan objek tersebut. Berikut contoh sintaks untuk mengakses fungsi anggota dari nested class.

// deklarasi kelas luar 

class KelasLuar { 

    var str = "Kelas luar" 

    // deklarasi kelas bersarang 

    class KelasBersarang {
        var s1 = "Kelas bersarang" 

        // fungsi anggota kelas bersarang 

        fun fungsiBersarang(str2: String): String { 

            var s2 = s1.plus(str2) 

            return s2 

        } 

    }
}



fun main(args: Array<String>) {
// membuat objek KelasBersarang
    val bersarang = KelasLuar.KelasBersarang()
    // memanggil fungsi bersarang dengan mengirimkan string
    var hasil = bersarang.fungsiBersarang(" pemanggilan fungsi anggota  berhasil")
    println(hasil)
}

Output:

Pemanggilan fungsi anggota kelas bersarang berhasil

Kotlin Inner Class

Ketika suatu kelas dapat dideklarasikan dalam kelas lain menggunakan kata kunci inner, maka kelas tersebut dapat disebut dengan inner class atau kelas dalam. Dengan bantuan kelas inner, properti kelas luar dapat diakses di dalam kelas inner tersebut. Berikut adalah contoh sintaks deklarasi untuk kelas dalam atau inner class.

class KelasLuar { 

      ............ 

      // properti atau fungsi anggota kelas luar inner 

      

      class KelasInner { 

            .......... 

            // properti atau fungsi anggota kelas dalam 

      } 

}

Program Inner Class Kotlin

Dalam contoh sintaks program di bawah ini, variabel str dapat diakses dari fungsi anggota inner class. Namun pada saat kompilasi, contoh sintaks tersebut menghasilkan kesalahan atau error.

// deklarasi kelas luar 

class KelasLuar { 

    var str = "Kelas luar" 

    // deklarasi KelasInner tanpa menggunakan kata kunci inner 

    class KelasInner { 

        var s1 = "Kelas inner" 

        fun fungsiBersarang(): String { 

            // tidak dapat mengakses properti str kelas luar 

            var s2 = str 

            return s2 

        } 

    } 

} 




// fungsi utama 

fun main(args: Array<String>) { 

    // membuat objek untuk kelas inner 

    val inner= KelasLuar().KelasInner() 

    // memanggil fungsi inner menggunakan objek 

    println(inner.fungsiBersarang()) 

}

Output:

Error:(9, 22) Kotlin: Unresolved reference: str

Pertama, gunakan kata kunci inner di depan kelas dalam. Kemudian, buat contoh dari kelas luar untuk menggunakan inner class, jika kelas luar tidak ditambahkan, maka kelas dalam tidak dapat digunakan. Berikut contoh sintaks kode untuk mengakses kelas luar.

// deklarasi kelas luar 

class KelasLuar { 

    var str = "Kelas luar" 

    // deklarasi KelasInner dengan menggunakan kata kunci inner inner 

    inner class KelasInner { 

        var s1 = "Kelas inner" 

        fun fungsiBersarang(): String { 

            // dapat mengakses properti str kelas luar 

            var s2 = str 

            return s2 

        } 

    } 

} 




// fungsi utama 

fun main(args: Array<String>) { 

    // membuat objek untuk kelas inner 

    val inner= KelasLuar().KelasInner()
    // memanggil fungsi inner menggunakan objek
    println(inner.fungsiBersarang() + " properti berhasil diakses dari kelas inner ")
}

Output:

Properti kelas luar berhasil diakses dari kelas inner

Perbandingan Inner Nested Class Kotlin dengan Java

Kelas inner nested class pada Kotlin sangat mirip dengan kelas yang sama pada bahasa pemrograman Java dalam hal kemampuan dan kasus penggunaan namun tidak identik satu sama lain. Kelas bersarang dalam bahasa pemrograman Kotlin mirip dengan kelas bersarang statis dalam Java, sedangkan kelas inner atau inner class mirip dengan kelas bersarang non-statis dalam Java.

Kelebihan dan Kekurangan Inner Nested Class Kotlin

Dalam penggunaan inner nested class kotlin terdapat beberapa kelebihan yang bisa diperoleh. Namun, selain keuntungan tersebut juga terdapat beberapa kekurangan yang harus digaris bawahi dalam proses pengembangan. Berikut adalah beberapa kelebihan dan kekurangan dalam penggunaan nested class dan inner class Kotlin.

Kelebihan menggunakan inner nested class Kotlin

1. Enkapsulasi : Kelas bersarang dan kelas dalam memungkinkan Anda mengelompokkan fungsionalitas terkait dan menjaga agar terpisah dari kode lain, sehingga meningkatkan organisasi dan keterbacaan kode.
2. Penggunaan kembali (Reusability) : Kelas bersarang dan kelas dalam dapat digunakan kembali dalam kelas yang sama atau di beberapa kelas, sehingga memudahkan penulisan kode yang lebih mudah dipelihara.
3. Aksesibilitas : Kelas dalam memiliki akses ke anggota kelas luar, sehingga memudahkan berbagi data di antara keduanya dan mengurangi duplikasi kode.

Kekurangan menggunakan inner nested class Kotlin

1. Kompleksitas : Menambahkan kelas bersarang dan kelas dalam dapat membuat kode lebih kompleks dan sulit dipahami, terutama jika ada beberapa tingkatan nesting atau jika kelas dalam digunakan secara berlebihan.
2. Performa : Menggunakan kelas bersarang dan kelas dalam dapat memperlambat kinerja kode Anda, terutama jika mereka digunakan secara intensif atau jika mereka bersarang ke tingkat yang dalam.
3. Debugging : Debugging kelas bersarang dan kelas dalam bisa menjadi tantangan, terutama jika ada beberapa tingkatan nesting atau jika kelas dalam digunakan secara berlebihan.

Penutup

Inner nested class dalam Kotlin merupakan konsep yang penting dalam pengorganisasian kode dan enkapsulasi. Melalui pemahaman yang baik tentang kelas bersarang dan kelas dalam, kita dapat menulis kode yang lebih rapi, mudah dipelihara, dan dapat digunakan kembali. Namun, perlu diingat bahwa penggunaan kelas bersarang dan kelas dalam yang tidak tepat dapat menimbulkan kompleksitas, penurunan kinerja, dan kesulitan dalam debugging. Oleh karena itu, penting untuk menggunakan kelas bersarang dan kelas dalam secara seimbang dan tepat. Semoga tutorial diatas bermanfaat untuk Anda!

Temukan lebih banyak artikel seri belajar Kotlin maupun bahasa pemrograman lainnya hanya di CODEKEY. Klik https://codekey.id/ sekarang juga untuk langsung belajar gratis dan tak ketinggalan tutorial pemrograman menarik lainnya. Sampai bertemu lagi!