Belajar Menggunakan Exception Handling di Kotlin

Exception Handling

Kode yang baik yaitu kode yang terhindar dari segala bentuk kejadian dengan efek buruk pada aplikasi kita. Kejadian tersebut pada programming disebut Exception. Hal terburuk yang disebabkan oleh exception ini adalah dapat terhentinya aplikasi ketika dijalankan. Hal seperti ini seharusnya kita hindari. Nah karena itu kita harus mengetahui cara menangani suatu exception (Exception Handling).

Apa itu Exception?

Exception adalah event (kejadian) yang dapat mengacaukan jalannya suatu program. Pada Kotlin semua exception bersifat Unchecked, yang artinya exception terjadi karena kesalahan pada kode kita. Berikut ini beberapa contoh Unchecked Exception yang sering mengganggu jalannya program kita:

• ArithmeticException
• NumberFormatException
• NullPointerException

ArithmeticException merupakan exception yang terjadi karena kita membagi suatu bilangan dengan nilai nol. Berikut merupakan contoh kode yang dapat membangkitkan ArithmeticException.

fun main() {
    val someValue = 6
    println(someValue / 0)
}
 
/*
output:
    Exception in thread "main" java.lang.ArithmeticException: / by zero
*/

NumberFormatException disebabkan karena terjadi kesalahan dalam format angka. Sebagai contoh, kita akan mengubah sebuah nilai String menjadi Integer tetapi nilai String yang akan kita ubah tidak memiliki format angka yang benar, sehingga dapat membangkitkan NumberFormatException. Berikut contoh kodenya:

fun main() {
    val someStringValue = "18.0"
    println(someStringValue.toInt())
}
 
/*
output:
    Exception in thread "main" java.lang.NumberFormatException: For input string: "18.0"
*/

Dan yang terakhir adalah NullPointerException atau NPE. Walaupun Kotlin memiliki operator Null Safety, NPE tetap bisa saja terjadi. 

NPE terjadi karena sebuah variabel atau objek memiliki nilai null, padahal seharusnya objek atau variabel tersebut tidak boleh null. Berikut contoh kasus yang dapat menyebabkan NullPointerException:

fun main() {
    val someNullValue: String? = null
    val someMustNotNullValue: String = someNullValue!!
    println(someMustNotNullValue)
}
 
/*
output:
    Exception in thread "main" kotlin.NullPointerException at MainKt.main(Main.kt:3)
*/

Exception handling dapat diterapkan dengan beberapa cara. Di antaranya adalah dengan menggunakan try-catch, try-catch-finally, dan multiple catch. Mari kita pelajari ketiga cara tersebut.

try-catch

Salah satu cara untuk menangani suatu exception adalah menggunakan try-catch. Kode yang dapat membangkitkan suatu exception disimpan dalam blok try, dan jika exception tersebut terjadi, maka blok catch akan terpanggil. Berikut cara penulisan try-catch pada Kotlin: 

try {
    // Block try, menyimpan kode yang membangkitkan exception
} catch (e: SomeException) {
    // Block catch akan terpanggil ketika exception bangkit.
}

Dengan menuliskan kode dalam blok try, kode kita menjadi terproteksi dari exception. Jika terjadi exception maka program tidak akan terhenti atau crash, namun akan dilempar menuju blok catch.  Di sana kita dapat menuliskan sebuah kode alternatif untuk menampilkan pesan eror atau yang lainnya.

fun main() {
    val someNullValue: String? = null
    lateinit var someMustNotNullValue: String
 
    try {
        someMustNotNullValue = someNullValue!!
        println(someMustNotNullValue)
    } catch (e: Exception) {
        someMustNotNullValue = "Nilai String Null"
        println(someMustNotNullValue)
    }
}
 
/*
output:
    Nilai String Null
*/

try-catch-finally

Selain terdapat blok try dan catch, ada juga blok finally. Hanya saja blok ini bersifat opsional. finally akan dieksekusi setelah program keluar dari blok try ataupun catch. Bahkan finally juga tereksekusi ketika terjadi exception yang tidak terduga. Exception tidak terduga terjadi ketika kita menggunakan NullPointerException pada catch namun exception yang terjadi adalah NumberFormatException. 

Sebagai contoh, mari kita ubah kode yang sebelumnya dengan menerapkan finally:

fun main() {
    val someNullValue: String? = null
    lateinit var someMustNotNullValue: String
 
    try {
        someMustNotNullValue = someNullValue!!
    } catch (e: Exception) {
        someMustNotNullValue = "Nilai String Null"
    } finally {
        println(someMustNotNullValue)
    }
}
 
/*
output:
    Nilai String Null
*/

Dengan menerapkan finally, fungsi println() cukup dituliskan pada blok finally.

Multiple Catch

Dari kode yang kita coba sebelumnya, kita menggunakan exception untuk menangani semua tipe exception yang terjadi. 

Baik itu ketika terjadi NullPointerException atau NumberFormatException. Sebenarnya pada catch kita dapat secara spesifik memilih tipe exception apa yang ingin ditangani. Multiple catch memungkinkan untuk penanganan exception dapat ditangani lebih dari satu tipe exception. 

Hal ini sangat berguna ketika kita ingin menangani setiap tipe exception dengan perlakuan yang berbeda. Berikut contoh struktur kode dengan menerapkan multiple catch:

try{
    // Block try, menyimpan kode yang membangkitkan exception
} catch (e: NullPointerException) {
    // Block catch akan terpanggil ketika terjadi NullPointerException.
} catch (e: NumberFormatException) {
    // Block catch akan terpanggil ketika terjadi NumberFormatException.
} catch (e: Exception) {
    // Block catch akan terpanggil ketika terjadi Exception selain keduanya.
}
finally {
    // Block finally akan terpanggil setelah keluar dari block try atau catch
}

Dari struktur kode di atas, kita dapat melihat terdapat 3 (tiga) blok catch. Block catch yang pertama menggunakan parameter NullPointerException, sehingga jika terjadi NullPointerException maka blok catch tersebut akan dieksekusi. 

Yang kedua block catch dengan parameter NumberFormatException, sehingga jika terjadi NumberFormatException maka blok tersebut yang akan dieksekusi. 

Dan yang terakhir blok catch dengan parameter Exception, blok ini akan menangani seluruh exception yang terjadi kecuali untuk dua exception yang telah ditentukan pada blok sebelumnya. 

Mari kita coba terapkan contoh kode yang sebelumnya kita buat dengan menggunakan multiple catch.

1. import kotlin.NumberFormatException
2.  
3. fun main() {
4.     val someStringValue: String? = null
5.     var someIntValue: Int = 0
6.  
7.     try {
8.         someIntValue = someStringValue!!.toInt()
9.     } catch (e: NullPointerException) {
10.         someIntValue = 0
11.     } catch (e: NumberFormatException) {
12.         someIntValue = -1
13.     } finally {
14.         when(someIntValue){
15.             0 -> println("Catch block NullPointerException terpanggil !")
16.             -1 -> println("Catch block NumberFormatException terpanggil !")
17.             else -> println(someIntValue)
18.         }
19.     }
20. }
21.  
22. /*
23. output:
24.     Catch block NullPointerException terpanggil!
25. */

Output kode di atas menjelaskan bahwa blok catch dengan parameter NullPointerException terpanggil. Sebabnya, pada variabel someStringValue kita menetapkan null sebagai nilainya.

Berbeda ketika kita menginisialisasi nilai someStringValue dengan nilai “12.0” maka exception yang akan terjadi adalah NumberFormatException dengan begitu blok catch kedua yang akan terpanggil dan akan menghasilkan output sebagai berikut:
Catch block NumberFormatException terpanggil!

Namun jika kedua exception tersebut tidak terjadi, dalam arti nilai someStringValue berhasil diubah dalam bentuk Integer, maka output yang dihasilkan adalah nilai dari Integernya tersebut. Contohnya, saat nilai someStringValue diinisialisasi dengan nilai “12.” Berikut ini hasilnya. :

12