try-catch Java: Menangani Exception Tanpa Crash

Menangkap Exception Alih-alih Crash

Kamu sudah tahu bahwa saat terjadi masalah, Java melempar exception, dan exception yang tidak ditangani akan menghentikan programmu dengan stack trace. Blok try-catch adalah cara kamu mengambil kendali: kamu membungkus kode yang berisiko di dalam try, dan kalau kode itu melempar exception, Java melompat ke blok catch yang cocok alih-alih crash.

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;          // throws ArithmeticException
            System.out.println(result);   // never reached
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program keeps running");
    }
}

Begitu 10 / 0 melempar exception, sisa blok try dilewati dan alur program pindah ke catch. Setelah catch selesai, eksekusi berlanjut seperti biasa, jadi program tidak mati.

Variabel catch Berisi Exception-nya

e di catch (ArithmeticException e) adalah objek sungguhan. Objek ini membawa informasi tentang apa yang salah, dan yang paling berguna adalah pesannya:

public class Main {
    public static void main(String[] args) {
        try {
            int n = Integer.parseInt("not a number");
            System.out.println(n);
        } catch (NumberFormatException e) {
            System.out.println("Bad input: " + e.getMessage());
        }
    }
}

e.getMessage() mengembalikan deskripsi singkat. Saat debugging, e.printStackTrace() menampilkan trace lengkap yang menunjukkan dengan tepat dari mana exception itu berasal. Pakai itu kalau pesan saja tidak cukup untuk menemukan penyebabnya.

Tangkap Tipe yang Spesifik, Bukan Semuanya

Blok catch hanya menangkap exception yang cocok dengan tipe yang dideklarasikannya (atau subclass-nya). Kesalahan pemula yang paling besar adalah menangkap Exception supaya masalahnya "hilang":

// Don't do this - it hides real bugs
try {
    doWork();
} catch (Exception e) {
    // swallows NullPointerException, typos, logic errors... everything
}

Tangkap tipe paling sempit yang benar-benar bisa kamu tangani. Kalau kamu mengantisipasi input angka yang salah, tangkap NumberFormatException. Apa pun yang tidak kamu antisipasi sebaiknya dibiarkan menjalar keluar, supaya kamu benar-benar mengetahuinya, bukan diam-diam melanjutkan program dalam keadaan rusak.

Menangani Beberapa Tipe Exception

Kamu bisa menumpuk beberapa blok catch. Java memeriksanya dari atas ke bawah dan menjalankan yang pertama cocok, jadi urutkan dari yang paling spesifik ke yang paling umum:

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"42", "oops", null};

        for (String s : inputs) {
            try {
                int n = Integer.parseInt(s);
                System.out.println("Parsed: " + n);
            } catch (NumberFormatException e) {
                System.out.println("Not a number: " + s);
            } catch (NullPointerException e) {
                System.out.println("Got a null value");
            }
        }
    }
}

Kalau dua tipe ditangani dengan cara yang sama, pakai satu multi-catch dengan | alih-alih menduplikasi bloknya:

public class Main {
    public static void main(String[] args) {
        try {
            Object[] words = {"a", "b"};
            System.out.println(words[5]);   // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("Bad access: " + e.getClass().getSimpleName());
        }
    }
}

Satu jebakan: tipe yang lebih umum harus ditulis setelah tipe yang spesifik. Menaruh catch (Exception e) di urutan pertama membuat blok-blok yang lebih spesifik di bawahnya tidak pernah bisa dicapai, dan compiler akan menolaknya.

finally Selalu Berjalan

Blok finally berjalan setelah try dan catch mana pun, apa pun yang terjadi: berhasil, exception yang tertangkap, atau bahkan return lebih awal. Di sinilah tempat pembersihan yang harus selalu terjadi.

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening resource");
            int x = 1 / 0;                 // throws
            System.out.println("Working");  // skipped
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Closing resource");  // runs no matter what
        }
    }
}

"Closing resource" tetap dicetak, entah exception-nya terjadi atau tidak. Tapi hindari melakukan return dari dalam finally, karena bisa diam-diam membuang exception atau menimpa nilai yang dikembalikan dari blok try.

try-with-resources Menutupnya untukmu

Saat kamu bekerja dengan sesuatu yang harus ditutup, seperti file, koneksi jaringan, atau statement database, mendeklarasikannya di dalam try (...) akan menutupnya secara otomatis saat blok selesai, bahkan kalau exception dilempar. Tipe apa pun yang mengimplementasikan interface AutoCloseable bisa dipakai.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner implements AutoCloseable, so it closes automatically
        try (Scanner sc = new Scanner("10 20 30")) {
            int sum = 0;
            while (sc.hasNextInt()) {
                sum += sc.nextInt();
            }
            System.out.println("Sum: " + sum);
        }
    }
}

Cara ini menggantikan pola lama yang membuka di try lalu menutup di finally, dan lebih kecil kemungkinan salahnya karena kamu tidak mungkin lupa menutupnya. Utamakan cara ini setiap kali kamu berurusan dengan resource yang bisa ditutup.

Jangan Pakai Exception untuk Alur Program Biasa

try-catch dibuat untuk situasi yang luar biasa, bukan kondisi biasa. Menangkap exception lebih mahal daripada pengecekan biasa, dan membuat kode lebih sulit dibaca. Kalau kamu bisa menguji kondisinya lebih dulu dengan pengecekan if-else, lakukan itu:

// Avoid: using a catch to test for a missing key
try {
    process(map.get(key).trim());
} catch (NullPointerException e) {
    // handle missing key
}

// Prefer: check explicitly
String value = map.get(key);
if (value != null) {
    process(value.trim());
}

Simpan catch untuk hal-hal yang benar-benar di luar kendalimu: input pengguna yang salah, file yang hilang, kegagalan jaringan.

Berikutnya: NullPointerException

Exception paling umum yang akan kamu tangkap (dan kamu sebabkan) di Java adalah NullPointerException. Exception ini muncul begitu kamu memanggil method pada sesuatu yang ternyata null. Berikutnya kita akan membahas dengan tepat apa yang memicunya, cara membaca stack trace-nya, dan kebiasaan yang mencegahnya terjadi sejak awal.