Pengecualian di Jawa (Pengecualian Java)

Dalam kehidupan sehari-hari, terkadang muncul situasi yang tidak kita rencanakan. Misalnya, Anda bangun kerja di pagi hari, mencari charger untuk ponsel, tapi tidak ada. Anda pergi ke kamar mandi untuk mencuci muka - airnya telah dimatikan. Saya masuk ke dalam mobil dan mobil tidak mau menyala. Tetapi seseorang dapat mengatasi situasi yang tidak terduga dengan cukup mudah. Kami akan mencoba mencari tahu bagaimana program Java menanganinya di artikel ini.

Apa saja pengecualian java

Dalam dunia pemrograman, terjadinya kesalahan dan situasi yang tidak terduga pada saat eksekusi program disebut dengan pengecualian. Dalam suatu program, pengecualian dapat terjadi sebagai akibat dari tindakan pengguna yang salah, kurangnya sumber daya yang diperlukan pada disk, atau hilangnya koneksi ke server melalui jaringan. Pengecualian pada saat eksekusi program juga dapat disebabkan oleh kesalahan pemrograman atau penggunaan API yang salah. Berbeda dengan dunia kita, program harus mengetahui dengan jelas apa yang harus dilakukan dalam situasi seperti ini. Java menyediakan mekanisme pengecualian untuk tujuan ini.

Secara singkat tentang kata kunci coba, tangkap, akhirnya, lempar

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

• coba - mendefinisikan blok kode di mana pengecualian dapat terjadi;
• catch – mendefinisikan blok kode di mana pengecualian ditangani;
• akhirnya – mendefinisikan blok kode yang opsional, tetapi jika ada, tetap dieksekusi, terlepas dari hasil blok percobaan.

Kata kunci ini digunakan untuk membuat konstruksi pemrosesan khusus dalam kode program: coba{}tangkap, coba{}tangkap{}akhirnya, coba{}akhirnya{}.

• throw – 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:

//method reads a string from the keyboard

public String input() throws MyException {//warn with throws,
// that the method can throw MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// in the try block we enclose the code in which an exception can occur, in this
// if the compiler tells us that the readLine() method of the class
// BufferedReader may throw an I/O exception
    try {
        s = reader.readLine();
// in the catch block we enclose the code for handling the IOException exception
    } catch (IOException e) {
        System.out.println(e.getMessage());
// close the read stream in the finally block
    } finally {
// when closing the stream, an exception is also possible, for example, if it was not opened, so we “wrap” the code in a try block
        try {
            reader.close();
// write exception handling when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// we decided that an empty string could disrupt the work of our program in the future, for example, on the result of this method, we need to call the substring(1,2) method, so we are forced to interrupt the program execution with the generation of our exception type MyException using throw
        throw new MyException("String can not be empty!");
    }
    return s;
}

Mengapa kita memerlukan mekanisme pengecualian?

Mari kita lihat contoh dunia nyata. Bayangkan ada suatu ruas jalan raya yang memiliki jembatan darurat dengan daya dukung terbatas. Jika kendaraan dengan massa melebihi daya dukung jembatan melewatinya, maka jembatan tersebut dapat runtuh, dan situasi bagi pengemudi dapat menjadi, secara halus, luar biasa. Untuk mencegah hal ini terjadi, pihak dinas jalan memasang rambu peringatan di jalan terlebih dahulu. Pengemudi mobil sambil melihat tanda peringatan akan membandingkan berat mobilnya dengan berat yang diperbolehkan untuk dikendarai di jembatan. Jika melebihi itu, dia akan mengambil jalan memutar. Berkat tindakan dinas jalan raya, pengemudi truk, pertama, diberikan kesempatan untuk mengubah rute terlebih dahulu, kedua, mereka diperingatkan tentang bahaya di jalur utama, dan, terakhir, mereka diperingatkan tentang ketidakmungkinan menggunakan jembatan dalam kondisi tertentu. Kemampuan untuk mencegah dan menyelesaikan pengecualian dalam suatu program agar dapat berlanjut adalah salah satu alasan penggunaan pengecualian di Java. Mekanisme pengecualian juga memungkinkan Anda untuk melindungi kode yang Anda tulis (antarmuka pemrograman) dari penyalahgunaan oleh pengguna dengan memvalidasi (memeriksa) data yang masuk. Sekarang mari kita menjadi polisi lalu lintas sebentar. Pertama, Anda harus mengetahui tempat-tempat yang dapat menimbulkan masalah bagi pengendara. Kedua, Anda perlu menyiapkan dan memasang rambu peringatan. Terakhir, Anda perlu menyediakan jalur memutar jika terjadi bahaya di jalur utama. Di Java, mekanisme pengecualian bekerja dengan cara yang sama. Pada tahap pengembangan program, kita “melindungi” bagian kode yang berbahaya dari pengecualian menggunakan blok try{}, menyediakan jalur “cadangan” menggunakan blok catch{}, dan di blok last{} kita menulis kode yang dieksekusi di program untuk hasil apa pun. Dalam kasus di mana kami tidak dapat memberikan “rute darurat” atau dengan sengaja ingin menyerahkan pilihan kepada pengguna, setidaknya kami harus memperingatkan dia tentang bahayanya. Mengapa? Bayangkan saja kemarahan seorang pengemudi yang akan mencapai jembatan darurat yang tidak dapat dilewati tanpa menemui satu pun tanda peringatan di sepanjang jalan! Dalam pemrograman, saat menulis kelas dan metode kami, kami tidak selalu dapat memperkirakan konteks penggunaannya oleh pengembang lain dalam program mereka, jadi kami tidak dapat memperkirakan jalur yang 100% benar untuk menyelesaikan situasi pengecualian. Pada saat yang sama, merupakan praktik yang baik untuk memperingatkan pengguna kode kami tentang kemungkinan pengecualian. Mekanisme pengecualian Java memungkinkan kita melakukan hal ini dengan menggunakan throws—yang pada dasarnya mendeklarasikan perilaku umum metode kita untuk melemparkan pengecualian, sehingga menyerahkan kepada pengguna metode tersebut untuk menulis kode guna menangani pengecualian di Java.

Peringatan "masalah"

Bila Anda tidak berencana menangani pengecualian dalam metode Anda, namun ingin memperingatkan pengguna metode tentang kemungkinan situasi pengecualian, gunakan kata kunci throws. 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 memberikan pengguna hak untuk menyesuaikan implementasi pengendali pengecualian. Setelah pelemparan, kami menunjukkan jenis pengecualian yang dilempar. Ini biasanya merupakan turunan dari kelas Java Exception . Karena Java adalah bahasa berorientasi objek, semua pengecualian di Java adalah objek.

Hirarki Pengecualian Java

Ketika kesalahan terjadi selama eksekusi program, runtime JVM membuat objek dari tipe yang diperlukan dari hierarki pengecualian Java - kumpulan kemungkinan pengecualian yang diwarisi dari "nenek moyang" umum - kelas Throwable. Situasi luar biasa yang terjadi dalam suatu program dapat dibagi menjadi dua kelompok:

1. Situasi di mana pemulihan operasi normal lebih lanjut dari program tidak mungkin dilakukan
2. Pemulihan mungkin terjadi.

Kelompok pertama mencakup situasi ketika pengecualian yang diwarisi dari kelas Error terjadi . Ini adalah kesalahan yang terjadi selama eksekusi program sebagai akibat dari kegagalan JVM, memori berlebih, atau kerusakan sistem. Mereka biasanya menunjukkan masalah serius yang tidak dapat diperbaiki dengan perangkat lunak. Jenis pengecualian di Java ini tergolong tidak dicentang pada tahap kompilasi. Grup ini juga mencakup RuntimeException - pengecualian, pewaris kelas Exception , yang dihasilkan oleh JVM selama eksekusi program. Hal ini sering kali disebabkan oleh kesalahan pemrograman. Pengecualian ini juga tidak dicentang pada waktu kompilasi, jadi tidak perlu menulis kode untuk menanganinya. Kelompok kedua mencakup situasi luar biasa yang diperkirakan pada tahap penulisan program, dan untuk itu kode pemrosesan harus ditulis. Pengecualian tersebut diperiksa. Sebagian besar pekerjaan pengembang Java ketika menangani pengecualian adalah menangani situasi seperti itu.

Membuat Pengecualian

Selama eksekusi program, pengecualian dilemparkan oleh JVM atau secara manual menggunakan pernyataan throw . Ini menciptakan objek pengecualian di memori dan mengganggu eksekusi kode program utama sementara pengendali pengecualian JVM mencoba menemukan cara untuk menangani pengecualian tersebut.

Penanganan Pengecualian

Pembuatan blok kode yang kami sediakan penanganan pengecualiannya di Java dilakukan dalam program menggunakan konstruksi try{}catch, try{}catch{}finally, try{}finally{}. Ketika pengecualian dimunculkan di blok coba, pengendali pengecualian dicari di blok tangkapan berikut. Jika tangkapan berisi pengendali untuk jenis pengecualian ini, kendali akan diteruskan ke sana. Jika tidak, JVM akan mencari handler untuk tipe pengecualian tersebut dalam rangkaian pemanggilan metode hingga tangkapan yang sesuai ditemukan. Setelah blok catch dijalankan, kontrol diteruskan ke blok final opsional . Jika blok tangkapan yang sesuai tidak ditemukan, JVM menghentikan eksekusi program dan menampilkan tumpukan panggilan metode - pelacakan tumpukan , setelah sebelumnya mengeksekusi kode 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 method print: " + 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 was processed. Program continues");
            }
            finally {
                System.out.println("Inside bloсk finally");
            }
            System.out.println("Go program....");
            System.out.println("-----------------");
        }

    }
    }

Hasil dari metode utama :

Inside method print: first step
Inside bloсk finally
Go program....
-----------------
Exception: s is null!
Exception was processed. Program continues
Inside bloсk finally
Go program....
-----------------
Inside method print: second step
Inside bloсk finally
Go program....
-----------------

Blok ini finallybiasanya digunakan untuk menutup aliran yang dibuka di blok percobaan atau untuk membebaskan sumber daya. Namun, saat menulis sebuah program, tidak selalu mungkin untuk melacak penutupan semua sumber daya. Untuk membuat hidup kita lebih mudah, pengembang Java menawarkan kepada kita sebuah konstruksi try-with-resourcesyang secara otomatis menutup sumber daya yang dibuka di blok percobaan. Contoh pertama kita dapat ditulis ulang seperti ini 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 ("String can not be empty!");
    }
    return s;
}

Berkat kemampuan Java, mulai dari versi 7, kami juga dapat menggabungkan penangkapan berbagai jenis pengecualian dalam satu blok, menjadikan kode lebih ringkas dan mudah dibaca. Misalnya:

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

Hasil

Menggunakan pengecualian di Java memungkinkan kita untuk meningkatkan toleransi kesalahan program melalui penggunaan jalur "cadangan", memisahkan logika kode utama dari kode penanganan pengecualian melalui penggunaan blok catch, dan juga memberi kita kesempatan untuk mendelegasikan penanganan pengecualian kepada pengguna kode kita menggunakan lemparan.