Pengecualian dalam Java (Pengecualian Java)

Dalam kehidupan seharian, kadang-kadang timbul situasi yang tidak kita rancang. Contohnya, anda bangun untuk bekerja pada waktu pagi, mencari pengecas untuk telefon anda, tetapi tiada satu. Anda pergi ke bilik air untuk mencuci muka - air telah dimatikan. Saya masuk ke dalam kereta dan ia tidak akan dihidupkan. Tetapi seseorang dapat menghadapi situasi yang tidak dijangka dengan mudah. Kami akan cuba memikirkan cara program Java menanganinya dalam artikel ini.

Apakah pengecualian java

Dalam dunia pengaturcaraan, berlakunya ralat dan situasi yang tidak dijangka semasa pelaksanaan program dipanggil pengecualian. Dalam program, pengecualian boleh berlaku akibat tindakan pengguna yang salah, kekurangan sumber yang diperlukan pada cakera, atau kehilangan sambungan ke pelayan melalui rangkaian. Pengecualian semasa pelaksanaan program juga boleh disebabkan oleh ralat pengaturcaraan atau penggunaan API yang salah. Tidak seperti dunia kita, program ini mesti tahu dengan jelas apa yang perlu dilakukan dalam keadaan sedemikian. Java menyediakan mekanisme pengecualian untuk tujuan ini.

Secara ringkas tentang kata kunci cuba, tangkap, akhirnya, lempar

Pengendalian pengecualian dalam Java adalah berdasarkan penggunaan kata kunci berikut dalam program:

• cuba - mentakrifkan blok kod di mana pengecualian boleh berlaku;
• catch – mentakrifkan blok kod di mana pengecualian dikendalikan;
• akhirnya – mentakrifkan blok kod yang adalah pilihan, tetapi jika ada, dilaksanakan juga, tanpa mengira keputusan blok percubaan.

Kata kunci ini digunakan untuk mencipta binaan pemprosesan khas dalam kod program: cuba{}tangkap, cuba{}tangkap{}akhirnya, cuba{}akhirnya{}.

• melontar – digunakan untuk menimbulkan pengecualian;
• lontaran – digunakan dalam tandatangan kaedah untuk memberi amaran bahawa kaedah itu mungkin membuang pengecualian.

Contoh menggunakan 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 sebenar. Bayangkan bahawa terdapat bahagian di lebuh raya dengan jambatan kecemasan dengan kapasiti muatan terhad. Jika kenderaan dengan jisim melebihi kapasiti tampung jambatan itu melintasinya, ia mungkin runtuh, dan keadaan pemandu mungkin menjadi, secara sederhana, luar biasa. Untuk mengelakkan perkara ini berlaku, perkhidmatan jalan raya memasang papan tanda amaran di jalan raya terlebih dahulu. Pemandu kereta itu, melihat tanda amaran, akan membandingkan berat keretanya dengan yang dibenarkan untuk memandu di atas jambatan. Jika melebihinya, dia akan mengambil jalan memutar. Terima kasih kepada tindakan perkhidmatan jalan raya, pemandu trak, pertama, diberi peluang untuk menukar laluan mereka terlebih dahulu, kedua, mereka diberi amaran tentang bahaya di laluan utama, dan, akhirnya, mereka diberi amaran tentang ketidakmungkinan menggunakan jambatan dalam keadaan tertentu. Keupayaan untuk menghalang dan menyelesaikan pengecualian dalam program supaya ia dapat diteruskan adalah salah satu sebab untuk menggunakan pengecualian dalam Java. Mekanisme pengecualian juga membolehkan anda melindungi kod yang anda tulis (antara muka pengaturcaraan) daripada penyalahgunaan oleh pengguna dengan mengesahkan (menyemak) data masuk. Sekarang mari jadi polis trafik sekejap. Pertama, anda harus tahu tempat di mana pemandu boleh menghadapi masalah. Kedua, anda perlu menyediakan dan memasang tanda amaran. Akhir sekali, anda perlu menyediakan laluan lencongan sekiranya berlaku bahaya di laluan utama. Di Jawa, mekanisme pengecualian berfungsi dengan cara yang sama. Pada peringkat pembangunan program, kami "melindungi" bahagian kod berbahaya daripada pengecualian menggunakan blok{} try, menyediakan laluan "sandaran" menggunakan blok{} tangkapan dan dalam blok{} akhirnya kami menulis kod yang dilaksanakan dalam program untuk sebarang hasil. Dalam kes di mana kami tidak dapat menyediakan "laluan kecemasan" atau sengaja mahu menyerahkan pilihan kepada pengguna, kami mesti sekurang-kurangnya memberi amaran kepadanya tentang bahaya. kenapa? Bayangkan sahaja kemarahan seorang pemandu yang sampai ke jambatan kecemasan yang anda tidak boleh pandu melintasi tanpa melihat satu tanda amaran di sepanjang jalan! Dalam pengaturcaraan, semasa menulis kelas dan kaedah kami, kami tidak boleh sentiasa meramalkan konteks penggunaannya oleh pembangun lain dalam program mereka, jadi kami tidak dapat meramalkan cara 100% betul untuk menyelesaikan pengecualian. Pada masa yang sama, adalah amalan yang baik untuk memberi amaran kepada pengguna tentang kod kami tentang kemungkinan pengecualian. Mekanisme pengecualian Java membolehkan kami melakukan ini dengan menggunakan lontaran—pada asasnya mengisytiharkan kelakuan umum kaedah kami untuk membuang pengecualian, dengan itu menyerahkannya kepada pengguna kaedah untuk menulis kod untuk mengendalikan pengecualian dalam Java.

Amaran "masalah"

Apabila anda tidak bercadang untuk mengendalikan pengecualian dalam kaedah anda, tetapi ingin memberi amaran kepada pengguna kaedah tentang kemungkinan situasi pengecualian, gunakan kata kunci lontaran. Kata kunci dalam tandatangan kaedah ini bermakna dalam keadaan tertentu kaedah itu mungkin membuang pengecualian. Amaran ini adalah sebahagian daripada antara muka kaedah dan memberi pengguna hak untuk menyesuaikan pelaksanaan pengendali pengecualian. Selepas lontaran kami menunjukkan jenis pengecualian yang dilemparkan. Ini biasanya keturunan kelas Pengecualian Java . Memandangkan Java ialah bahasa berorientasikan objek, semua pengecualian dalam Java adalah objek.

Hierarki Pengecualian Java

Apabila ralat berlaku semasa pelaksanaan program, masa jalan JVM mencipta objek jenis yang diperlukan daripada hierarki pengecualian Java - set kemungkinan pengecualian yang diwarisi daripada "nenek moyang" biasa - kelas Throwable. Situasi luar biasa yang berlaku dalam program boleh dibahagikan kepada dua kumpulan:

1. Situasi di mana pemulihan operasi normal selanjutnya program adalah mustahil
2. Pemulihan adalah mungkin.

Kumpulan pertama termasuk situasi apabila pengecualian yang diwarisi daripada kelas Ralat berlaku . Ini adalah ralat yang berlaku semasa pelaksanaan program akibat daripada kegagalan JVM, limpahan memori atau ranap sistem. Mereka biasanya menunjukkan masalah serius yang tidak boleh diperbaiki menggunakan perisian. Pengecualian jenis ini dalam Java diklasifikasikan sebagai tidak ditanda pada peringkat penyusunan. Kumpulan ini juga termasuk RuntimeException - pengecualian, pewaris kelas Pengecualian , yang dijana oleh JVM semasa pelaksanaan program. Mereka sering disebabkan oleh ralat pengaturcaraan. Pengecualian ini juga dinyahtandai pada masa penyusunan, jadi menulis kod untuk mengendalikannya tidak perlu. Kumpulan kedua termasuk situasi luar biasa yang diramalkan pada peringkat menulis atur cara, dan yang mana kod pemprosesan mesti ditulis. Pengecualian sedemikian disemak. Sebahagian besar tugas pembangun Java apabila menangani pengecualian adalah mengendalikan situasi sedemikian.

Mencipta Pengecualian

Semasa pelaksanaan program, pengecualian dilemparkan oleh JVM atau secara manual menggunakan pernyataan lontaran . Ini mencipta objek pengecualian dalam ingatan dan mengganggu pelaksanaan kod program utama sementara pengendali pengecualian JVM cuba mencari cara untuk mengendalikan pengecualian.

Pengendalian Pengecualian

Penciptaan blok kod yang kami sediakan pengendalian pengecualian dalam Java dilakukan dalam atur cara menggunakan binaan try{}catch, try{}catch{}finally, try{}finally{}. Apabila pengecualian dinaikkan dalam blok percubaan, pengendali pengecualian dicari dalam blok tangkapan berikut. Jika tangkapan mengandungi pengendali untuk jenis pengecualian ini, kawalan beralih kepadanya. Jika tidak, JVM mencari pengendali untuk jenis pengecualian tersebut dalam rantaian panggilan kaedah sehingga tangkapan yang sesuai ditemui. Selepas blok tangkapan dilaksanakan, kawalan diserahkan kepada blok akhirnya pilihan . Jika blok tangkapan yang sesuai tidak ditemui, JVM menghentikan pelaksanaan program dan memaparkan timbunan panggilan kaedah - surih tindanan , setelah melaksanakan kod blok akhirnya, jika ada sebelum ini. Contoh pengendalian 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 kaedah 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 finallybiasanya digunakan untuk menutup aliran yang dibuka dalam blok cubaan atau untuk membebaskan sumber. Walau bagaimanapun, semasa menulis program, tidak selalu mungkin untuk menjejaki penutupan semua sumber. Untuk menjadikan kehidupan kami lebih mudah, pembangun Java menawarkan kami binaan try-with-resourcesyang menutup sumber secara automatik yang dibuka dalam blok percubaan. Contoh pertama kami boleh ditulis semula 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;
}

Terima kasih kepada keupayaan Java, bermula dengan versi 7, kami juga boleh menggabungkan penangkapan pelbagai jenis pengecualian dalam satu blok, menjadikan kod lebih padat dan boleh dibaca. Sebagai 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("String can not be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

Keputusan

Penggunaan pengecualian dalam Java membolehkan kami meningkatkan toleransi kesalahan program melalui penggunaan laluan "sandaran", untuk memisahkan logik kod utama daripada kod pengendalian pengecualian melalui penggunaan blok tangkapan, dan juga memberi kami peluang untuk mewakilkan pengendalian pengecualian kepada pengguna kod kami menggunakan lontaran.