Kotlin dari awal: Exception Handling

() translation by (you can also view the original English article)

Kotlin adalah bahasa pemrograman modern yang mengkompilasi ke Java bytecode. Bebas dan open source, dan membuat coding untuk Android bahkan lebih menyenangkan.

Dalam artikel sebelumnya, Anda akan belajar lebih banyak tentang pemrograman berorientasi obyek dengan menggali ke kelas abstrak, interface, pewarisan, dan tipe alias di Kotlin.

Dalam posting ini, Anda akan terus belajar tentang pemrograman di Kotlin dengan belajar tentang exception dan bagaimana untuk menangani mereka.

1. Menangani Excepetion

Exception yang digunakan untuk menunjukkan masalah dalam kode kita pada pelaksanaan program. Penaganan Exception adalah kemampuan untuk (atau menangani) Exception yang mungkin terjadi. Jika kami tidak menangani Exception yang terjadi, program kami akan menghentikan eksekusi tiba-tiba — aka segera crash.

Penangann Exception memungkinkan program untuk melanjutkan eksekusi bahkan jika ada exception (meskipun sangat dianjurkan untuk login Anda pengecualian dan laporan mereka menggunakan alat seperti Crashlytics crash reporting).

Di Java, kita memiliki dua jenis exception: checked dan unchecked. Saya akan secara singkat menjelaskan keduanya, tetapi kita akan mulai dengan unchecked exception.

Unchecked Exception

Berikut adalah exception yang dilemparkan karena kelemahan dalam kode Anda. Mereka adalah sebuah subclass langsung atau tidak langsung dari RuntimeException superclass.

Contoh unchecked exception termasuk:

ArithmeticException: dilempar ketika Anda membagi dengan nol.
ArrayIndexOutOfBoundExceptions: dilempar ketika array telah diakses dengan indeks ilegal.
SecurityException: dilemparkan oleh Manajer keamanan untuk menunjukkan pelanggaran keamanan.
NullPointerException: dilempar ketika menerapkan metode atau properti pada objek null.

Metode yang mungkin memunculkan exception dicentang tidak berisi informasi tentang pengecualian dilemparkan pada deklarasinya metode.

public Integer divideByZero(Integer numerator, Integer denominator) {
    return numerator / denominator;
}

divideByZero(7, 0) // throws ArithmeticException

Jenis dari exception dapat dicegah dengan pengkodean yang benar. Pada kode diatas, kita harus memiliki diperiksa jika penyebut adalah nol sebelum melakukan operasi. Untuk pengecualian ini, pengembang tidak perlu untuk menangkap exception menggunakan try... catch blok. Dengan kata lain, kita tidak dipaksa oleh kompilator untuk membungkus kode yang mungkin memicu pengecualian di try... catch blok. Sebaliknya, kita harus pastikan exception tidak pernah terjadi di awal.

Juga, ingat, Kotlin adalah bahasa yang aman dari null. Dengan kata lain, itu dapat membantu kita menghindari NullPointerExceptions dalam kode kita. Anda dapat membaca Nullability, loop, dan kondisi posting untuk mendapatkan penyegaran null safety dalam Kotlin.

Checked Exception di Java

Metode yang mungkin melempar exception perlu menyatakan dengan statemen dalam khasnya metode yang menggunakan kata kunci throws. Jika Anda memanggil metode yang melempar exception itu adalah checked exception, Anda juga perlu untuk membuangnya lagi dari fungsi Anda atau untuk menangkap dan menanganinya menggunakan try...catch blok.

Checked Exception adalah exception yang diperiksa pada waktu kompilasi. Jenis-jenis exception mewarisi dari kelas Exception. Contoh dari pengecualian semacam ini adalah IOException. Hal ini dapat terjadi ketika Anda mencoba untuk mengakses file yang tidak dapat dibuka karena tidak ada. (FileNotFoundException adalah sebuah subclass dari IOException.)

// perform in a background thread
public void editFile(File file, String text) {
    try {
        file.getParentFile().mkdirs();
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        Writer writer = new BufferedWriter(new OutputStreamWriter(fileOutputStream));
        try {
            writer.write(text);
            writer.flush();
            fileOutputStream.getFD().sync();
        } finally {
            writer.close();
        }
    } catch (IOException e) {
        // Log the exception
        e.printStackTrace();
    }
}

Dalam kode sebelumnya, kita menggunakan try... catch blok untuk menangani IOException di dalam metode editFile(). Kita sekarang dapat memanggil metode editFile() seperti biasa, dan kompilator tidak akan mengeluh.

1	editFile(new File(""), "my text");

Lihat kode di bawah ini, kita telah merefractor metode menggunakan throw kata kunci dalam pemanggilan metode. Ini menunjukkan kepada pemanggil bahwa mereka harus menangani exception IOException yang mungkin dilemparkan saat memanggil metode editFile().

// this should be in a background thread
public void editFile(File file, String text) throws IOException {
    file.getParentFile().mkdirs();
    FileOutputStream fileOutputStream = new FileOutputStream(file);
    Writer writer = new BufferedWriter(new OutputStreamWriter(fileOutputStream));
    try {
        writer.write(text);
        writer.flush();
        fileOutputStream.getFD().sync();
    } finally {
        writer.close();
    }
}

Untuk memanggil metode di atas, kita perlu membukusnya dengan try... catch blok untuk menangani exception.

try {
    editFile(new File(""), "my text");
} catch (IOException e) {
    e.printStackTrace();
}

Ini telah menjadi singkat melihat pengecualian di Java. Mari kita sekarang melihat bagaimana Kotlin menangani exception.

2. Exception di Kotlin

Perbedaan utama antara Kotlin dan Java mekanisme exception adalah bahwa semua exception adalah unchecked di Kotlin. Dengan kata lain, mereka tidak secara eksplisit dinyatakan dalam fungsi signature, seperti di Java.

fun editFile(file: File, text: String) {
    file.parentFile.mkdirs()
    val fileOutputStream = FileOutputStream(file)
    val writer = BufferedWriter(OutputStreamWriter(fileOutputStream))
    try {
        writer.write(text)
        writer.flush()
        fileOutputStream.fd.sync()
    } finally {
        writer.close()
    }
}

Di sini, kita telah mekonversi metode editFile() ke fungsi Kotlin. Anda dapat melihat bahwa fungsi tidak memiliki throw IOException pernyataan dalam khasnya fungsi. throw bahkan tidak kata kunci dalam Kotlin.

Juga, kita dapat memanggil fungsi ini tanpa membungkusnya dengan try... catch blok — dan kompilator tidak akan mengeluh. Dengan kata lain, ada ada hal seperti memeriksa pengecualian dalam Kotlin. Semua pengecualian dicentang. (Perhatikan bahwa jika ada pengecualian dilemparkan, pelaksanaan program akan berhenti seperti biasa.)

Jika kita berpikir exception ini mungkin timbul, kami masih harus menangani membungkus dengan try... catch blok- tetapi ini tidak dipaksakan oleh kompiler Kotlin.

try {
    editFile(File(""), "text 123")
} catch (e: IOException) {
    e.printStackTrace()
}

Jika excption yang dilemparkan di dalam fungsi editFile() adalah instance kelas IOException, catch blok akan dieksekusi, dan kita hanya mencetak pelacakan stack untuk keperluan debugging.

`Try... catch` blok

Try dengan catch dan finally klausul dalam Kotlin ini mirip dengan Java.

fun foo() {
    try {
        throw Exception("Exception message")
    } catch (e: Exception) {
        println("Exception handled")
    } finally {
        println("inside finally block")
    }
}

Di sini, kita membuang Exception objek di dalam blok try. Perhatikan kita tidak termasuk kata kunci new seperti yang kita lakukan di Java untuk membuat sebuah instance baru. Perhatikan juga bahwa kami tidak menetapkan exception yang akan dilemparkan pada signature fungsi seperti yang kita harus di Java.

Kami menangani semua subclass dan kelas jenis Exception di catch blok. Opsional finally blok selalu dijalankan — ini adalah dimana kita biasanya tutup koneksi yang sebelumnya dibuka sehingga dapat mencegah kebocoran sumber atau sumber daya. Misalnya, jika Anda membuka file atau membuat koneksi database atau jaringan di blok try, Anda harus menutup atau bebas dalam finally blok.

Perhatikan bahwa dalam Kotlin throw adalah ekspresi dan dapat menggabungkan dengan ekspresi lain.

val letter = 'c'
val result =
        if (letter in 'a'..'z')
            letter
        else
            throw IllegalArgumentException("A letter must be between a to z")

Juga, try juga dapat digunakan sebagai ekspresi.

fun foo(number: Int) {
    val result =  try {
        if (number != 1) {
            throw IllegalArgumentException()
        }
        true
    } catch (e: IllegalArgumentException) {
        false
    }

    println(result)
}

foo(2) // false

Di sini, kita diberi nilai kembali dari try... catch blok ke variabel result. Jika nomor tidak 1, itu melempar IllegalArgumentException dan catch blok dijalankan. Ekspresi false dalam blok catch akan ditempatkan ke variabel result. Jika nomor 1 sebaliknya, maka nilai true ekspresi akan ditempatkan ke variabel result.

Java Interop

Exception dalam Kotlin berperilaku seperti di Java - tetapi saya ingin membuat Anda menyadari anotasi berguna yang disebut @Throws di Kotlin yang mungkin akan berguna. Karena semua exception dalam Kotlin unchecked, pengembang yang mengkonsumsi kode Kotlin dari Java mungkin tidak akan menyadari bahwa fungsi Anda melempar exception. Namun, Anda masih dapat menambahkan kemungkinan exception yang mungkin dilemparkan ke method signature dengan anotasi @Throw. Ini akan mengingatkan Java pemanggil bahwa mereka harus menangani exception.

Mari kita lihat sebuah contoh praktis dari penjelasan ini.

/* Functions.kt file */
fun addNumberToTwo(a: Any): Int {
    if (a !is Int) {
        throw IllegalArgumentException("Number must be an integer")
    }
    return 2 + a
}

Di sini, kita mendefinisikan fungsi Kotlin yang dapat memunculkan exception IllegalArgumentException hanya jika jenis yang dilewatkan ke fungsi bukan tipe Int.

Kita memanggil addNumberToTwo() top-level fungsi ini langsung dari Java dengan cara sebagai berikut:

1	public void myJavaMethod() {
2	Integer result = FunctionsKt.addNumberToTwo(5);
3	System.out.println(result); // 7
4	}

Ini bekerja baik; kompilator tidak mengeluh. Namun, jika kita ingin berkomunikasi dengan Java pemanggil bahwa fungsi top-level addNumberToTwo() melempar sebuah exception, kami hanya menambahkan anotasi @Throws untuk fungsi signature.

@Throws(IllegalArgumentException::class)
fun addNumberToTwo(a: Any): Int {
    if(a !is Int) {
        throw IllegalArgumentException("Number must be an integer")
    }
    return 2 + a
}

Penjelasan @Throws ini dapat menerima dipisahkan dengan koma daftar argumen class exception. Pada kode diatas, kita hanya memasukan satu exception class-IllegalArgumentException.

Sekarang kita harus memperbarui kami kode Java untuk menangani exception.

1	public void myJavaMethod() throws IllegalArgumentException {
2	Integer result = FunctionsKt.addNumberToTwo(5);
3	System.out.println(result);
4	}

Jika kita mendekompilasi fungsi addNumberToTwo() Kotlin, menggunakan fitur Show Kotlin Bytecode (jika Anda berada di IntelliJ IDEA atau Android Studio, menggunakan Tools > Kotlin > Show Kotlin Bytecode), kita akan melihat kode Java berikut:

// ... 
public static final int addNumberToTwo(@NotNull Object a) throws IllegalArgumentException {
   Intrinsics.checkParameterIsNotNull(a, "a");
   if (!(a instanceof Integer)) {
      throw (Throwable)(new IllegalArgumentException("Number must be an integer"));
   } else {
      return 2 + ((Number)a).intValue();
   }
}
// ... 

Di atas kode Java (beberapa unsur kode yang dihapus untuk singkatnya), Anda dapat melihat bahwa kompilator ditambahkan kata kunci throw ke signature metode — karena kami termasuk anotasi @Throws.

Kesimpulan

Dalam tutorial ini, Anda akan belajar lebih banyak tentang pemrograman di Kotlin dengan melihat ke dalam exception. Kami melihat bahwa Kotlin tidak memiliki checked exception pengecualian tapi sebaliknya, Semua exception adalah unchecked. Kami juga melihat bagaimana menangani exception menggunakan try... catch blok dan melihat kegunaan anotasi @Throws di Kotlin untuk pemanggil Java.

Untuk mempelajari lebih lanjut tentang bahasa Kotlin, saya sarankan mengunjungi dokumentasi Kotlin. Atau check out beberapa kami Android app pembangunan posting lain di sini di Envato Tuts!