Pengecualian di Jawa

Halo! Dalam pelajaran hari ini, kita akan membahas tentang Pengecualian Java. Kehidupan sehari-hari penuh dengan situasi yang tidak kita antisipasi. Misalnya, Anda bangun untuk bekerja di pagi hari dan mencari pengisi daya ponsel, tetapi Anda tidak dapat menemukannya di mana pun. Anda pergi ke kamar mandi untuk mandi hanya untuk menemukan bahwa pipanya membeku. Anda masuk ke mobil Anda, tetapi tidak mau hidup. Manusia mampu mengatasi keadaan yang tidak terduga seperti itu dengan cukup mudah. Pada artikel ini, kami akan mencoba mencari tahu bagaimana program Java menanganinya.

Apa itu pengecualian Java?

Dalam dunia pemrograman, kesalahan dan situasi tak terduga dalam eksekusi suatu program disebut exception. Dalam suatu program, pengecualian dapat terjadi karena tindakan pengguna yang tidak valid, ruang disk yang tidak mencukupi, atau hilangnya koneksi jaringan dengan server. Pengecualian juga dapat terjadi akibat kesalahan pemrograman atau penggunaan API yang salah. Tidak seperti manusia di dunia nyata, sebuah program harus tahu persis bagaimana menangani situasi ini. Untuk ini, Java memiliki mekanisme yang dikenal sebagai exception handling.

Beberapa kata tentang kata kunci

Penanganan pengecualian di Java didasarkan pada penggunaan kata kunci berikut dalam program:

• coba - mendefinisikan blok kode di mana pengecualian dapat terjadi;
• catch - menentukan blok kode tempat pengecualian ditangani;
• akhirnya - mendefinisikan blok kode opsional yang, jika ada, dijalankan terlepas dari hasil blok percobaan.

Kata kunci ini digunakan untuk membuat konstruksi khusus dalam kode: try{}catch , try{}catch{}finally , try{}finally{} .

• lemparan - digunakan untuk memunculkan pengecualian;
• throws - digunakan dalam tanda tangan metode untuk memperingatkan bahwa metode tersebut mungkin mengeluarkan pengecualian.

Contoh penggunaan kata kunci dalam program Java:

// This method reads a string from the keyboard

public String input() throws MyException { // Use throws to warn
// that the method may throw a MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// We use a try block to wrap code that might create an exception. In this case,
// the compiler tells us that the readLine() method in the
// BufferedReader class might throw an I/O exception
    try {
        s = reader.readLine();
// We use a catch block to wrap the code that handles an IOException
    } catch (IOException e) {
        System.out.println(e.getMessage());
// We close the read stream in the finally block
    } finally {
// An exception might occur when we close the stream if, for example, the stream was not open, so we wrap the code in a try block
        try {
            reader.close();
// Handle exceptions when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// We've decided that an empty string will prevent our program from working properly. For example, we use the result of this method to call the substring(1, 2) method. Accordingly, we have to interrupt the program by using throw to generate our own MyException exception type.
        throw new MyException("The string cannot be empty!");
    }
    return s;
}

Mengapa kita membutuhkan pengecualian?

Mari kita lihat contoh dari dunia nyata. Bayangkan sebuah bagian jalan raya memiliki jembatan kecil dengan kapasitas berat yang terbatas. Jika mobil yang lebih berat dari batas jembatan melewatinya, itu bisa runtuh. Situasi pengemudi akan menjadi, secara halus, luar biasa. Untuk menghindarinya, dinas perhubungan memasang rambu peringatan di jalan sebelum terjadi kesalahan. Melihat tanda peringatan tersebut, seorang pengemudi membandingkan berat kendaraannya dengan berat maksimal jembatan. Jika kendaraan terlalu berat, pengemudi mengambil jalan pintas. Dinas perhubungan, pertama memperbolehkan pengemudi truk untuk mengubah rute jika perlu, kedua, memperingatkan pengemudi tentang bahaya di jalan utama, dan ketiga, memperingatkan pengemudi bahwa jembatan tidak boleh digunakan dalam kondisi tertentu. Kemampuan untuk mencegah dan menyelesaikan situasi luar biasa dalam suatu program, yang memungkinkannya untuk terus berjalan, adalah salah satu alasan untuk menggunakan pengecualian di Java. Mekanisme pengecualian juga memungkinkan Anda melindungi kode (API) Anda dari penggunaan yang tidak benar dengan memvalidasi (memeriksa) masukan apa pun. Sekarang bayangkan Anda adalah departemen transportasi sebentar. Pertama, Anda perlu mengetahui tempat-tempat di mana pengendara dapat mengalami masalah. Kedua, Anda perlu membuat dan memasang tanda peringatan. Dan terakhir, Anda perlu memberikan jalan memutar jika muncul masalah di jalur utama. Di Jawa, mekanisme exception bekerja dengan cara yang sama. Selama pengembangan, kami menggunakan blok percobaan untuk membangun "penghalang pengecualian" di sekitar bagian kode yang berbahaya, kami menyediakan "rute cadangan" menggunakan tangkapan {}blok, dan kita menulis kode yang harus dijalankan apa pun yang terjadi di blok finally{} . Jika kami tidak dapat menyediakan "rute cadangan" atau kami ingin memberikan hak kepada pengguna untuk memilih, setidaknya kami harus memperingatkannya tentang bahaya tersebut. Mengapa? Bayangkan saja kemarahan seorang pengemudi yang, tanpa melihat satu pun tanda peringatan, mencapai jembatan kecil yang tidak dapat dia lewati! Dalam pemrograman, saat menulis kelas dan metode kami, kami tidak selalu dapat memperkirakan bagaimana mereka dapat digunakan oleh pengembang lain. Akibatnya, kami tidak dapat memperkirakan cara yang 100% benar untuk menyelesaikan situasi luar biasa. Yang mengatakan, itu bentuk yang baik untuk memperingatkan orang lain tentang kemungkinan situasi luar biasa. Mekanisme pengecualian Java memungkinkan kita melakukan ini dengan lemparankata kunci — pada dasarnya sebuah pernyataan bahwa perilaku umum metode kami mencakup melempar pengecualian. Jadi, siapa pun yang menggunakan metode ini tahu bahwa dia harus menulis kode untuk menangani pengecualian.

Memperingatkan orang lain tentang "masalah"

Jika Anda tidak berencana untuk menangani pengecualian dalam metode Anda, tetapi ingin memperingatkan orang lain bahwa pengecualian dapat terjadi, gunakan kata kunci lemparan . Kata kunci dalam tanda tangan metode ini berarti bahwa, dalam kondisi tertentu, metode tersebut dapat mengeluarkan pengecualian. Peringatan ini adalah bagian dari antarmuka metode dan memungkinkan penggunanya mengimplementasikan logika penanganan pengecualian mereka sendiri. Setelah lemparan, kami menentukan jenis pengecualian yang dilemparkan. Ini biasanya turun dari kelas Pengecualian Java . Karena Java adalah bahasa berorientasi objek, semua pengecualian adalah objek di Java.

Hirarki pengecualian

Saat terjadi kesalahan saat program sedang berjalan, JVM membuat objek dengan tipe yang sesuai dari hierarki pengecualian Java — sekumpulan kemungkinan pengecualian yang diturunkan dari leluhur bersama — kelas Throwable . Kami dapat membagi situasi runtime yang luar biasa menjadi dua kelompok:

1. Situasi di mana program tidak dapat pulih dan melanjutkan operasi normal.
2. Situasi di mana pemulihan dimungkinkan.

Grup pertama mencakup situasi yang melibatkan pengecualian yang diturunkan dari kelas Error . Ini adalah kesalahan yang terjadi karena kerusakan JVM, kelebihan memori, atau kegagalan sistem. Mereka biasanya menunjukkan masalah serius yang tidak dapat diperbaiki oleh perangkat lunak. Di Jawa, kemungkinan pengecualian semacam itu tidak diperiksa oleh kompiler, sehingga dikenal sebagai pengecualian yang tidak dicentang. Grup ini juga menyertakan RuntimeExceptions, yang merupakan pengecualian yang diturunkan dari Pengecualiankelas dan dihasilkan oleh JVM pada saat dijalankan. Mereka sering disebabkan oleh kesalahan pemrograman. Pengecualian ini juga tidak dicentang (tidak dicentang) pada waktu kompilasi, jadi Anda tidak perlu menulis kode untuk menanganinya. Kelompok kedua mencakup situasi luar biasa yang dapat diramalkan saat Anda menulis program (dan karenanya Anda harus menulis kode untuk menanganinya). Pengecualian seperti itu disebut pengecualian yang diperiksa. Dalam hal pengecualian, sebagian besar pekerjaan pengembang Java menangani situasi seperti itu.

Membuat pengecualian

Saat program berjalan, pengecualian dihasilkan oleh JVM atau secara manual menggunakan pernyataan lemparan . Ketika ini terjadi, objek pengecualian dibuat di memori, aliran utama program terganggu, dan penangan pengecualian JVM mencoba menangani pengecualian.

Penanganan pengecualian

Di Java, kami membuat blok kode yang mengantisipasi kebutuhan penanganan pengecualian menggunakan konstruksi try{}catch , try{}catch{}finally , dan try{}finally{} . Saat pengecualian dilemparkan ke blok coba , JVM mencari penangan pengecualian yang sesuai di blok tangkapan berikutnya . Jika blok tangkapan memiliki penangan pengecualian yang diperlukan, kontrol diteruskan ke sana. Jika tidak, maka JVM akan melihat lebih jauh ke bawah rantai blok penangkap hingga penangan yang sesuai ditemukan. Setelah mengeksekusi blok tangkap , kontrol ditransfer ke blok akhirnya opsional . Jika tangkapan yang cocokblok tidak ditemukan, maka JVM menghentikan program dan menampilkan jejak tumpukan (tumpukan panggilan metode saat ini), setelah pertama kali melakukan blok akhirnya jika ada. Contoh penanganan pengecualian:

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside print method: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s : list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception handled. The program will continue");
            }
            finally {
                System.out.println("Inside finally block");
            }
            System.out.println("The program is running...");
            System.out.println("-----------------");
        }

    }
    }

Berikut adalah hasil dari metode utama :

Inside print method: first step
Inside finally block
The program is running...
-----------------
Exception: s is null!
Exception handled. The program will continue
Inside finally block
The program is running...
-----------------
Inside print method: second step
Inside finally block
The program is running...
-----------------

Akhirnya biasanya digunakan untuk menutup aliran apa pun dan membebaskan semua sumber daya yang dibuka/dialokasikan dalam blok percobaan . Namun, saat menulis sebuah program, tidak selalu memungkinkan untuk melacak penutupan semua sumber daya. Untuk membuat hidup kita lebih mudah, pengembang Java menawarkan konstruk try-with-resources , yang secara otomatis menutup semua resource yang dibuka di blok try . Contoh pertama kita dapat ditulis ulang dengan try-with-resources :

public String input() throws MyException {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")) {
        throw new MyException ("The string cannot be empty!");
    }
    return s;
}

Berkat kemampuan Java yang diperkenalkan di versi 7, kami juga dapat menggabungkan pengecualian heterogen yang ditangkap ke dalam satu blok, membuat kode lebih ringkas dan mudah dibaca. Contoh:

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("The string cannot be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

Garis bawah

Menggunakan pengecualian di Java memungkinkan Anda membuat program Anda lebih kuat dengan membuat "rute cadangan", menggunakan blok tangkapan untuk memisahkan kode utama dari kode penanganan pengecualian, dan menggunakan lemparan untuk mengalihkan tanggung jawab penanganan pengecualian kepada siapa pun yang menggunakan metode Anda.