Pengecualian di Jawa

helo! Dalam pelajaran hari ini, kita akan bercakap tentang Pengecualian Java. Kehidupan seharian penuh dengan situasi yang tidak kita jangkakan. Contohnya, anda bangun untuk bekerja pada waktu pagi dan mencari pengecas telefon anda, tetapi anda tidak menemuinya di mana-mana. Anda pergi ke bilik mandi untuk mandi hanya untuk mengetahui bahawa paip itu beku. Anda masuk ke dalam kereta anda, tetapi ia tidak dapat dihidupkan. Seorang manusia mampu menghadapi keadaan yang tidak dijangka dengan mudah. Dalam artikel ini, kami akan cuba memikirkan cara program Java menanganinya.

Apakah pengecualian Java?

Dalam dunia pengaturcaraan, ralat dan situasi yang tidak dijangka dalam pelaksanaan program dipanggil pengecualian. Dalam program, pengecualian boleh berlaku disebabkan oleh tindakan pengguna yang tidak sah, ruang cakera yang tidak mencukupi atau kehilangan sambungan rangkaian dengan pelayan. Pengecualian juga boleh disebabkan oleh ralat pengaturcaraan atau penggunaan API yang salah. Tidak seperti manusia di dunia nyata, program mesti tahu dengan tepat bagaimana untuk menangani situasi ini. Untuk ini, Java mempunyai mekanisme yang dikenali sebagai pengendalian pengecualian.

Beberapa perkataan tentang kata kunci

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 pilihan kod yang, jika ada, dilaksanakan tanpa mengira keputusan blok cuba.

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

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

Contoh menggunakan 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 memerlukan pengecualian?

Mari kita lihat contoh dari dunia sebenar. Bayangkan bahawa bahagian lebuh raya mempunyai jambatan kecil dengan kapasiti berat yang terhad. Jika kereta yang lebih berat daripada had jambatan melintasinya, ia boleh runtuh. Keadaan untuk pemandu akan menjadi, secara sederhana, luar biasa. Untuk mengelakkan perkara ini, jabatan pengangkutan memasang papan tanda amaran di jalan raya sebelum apa-apa berlaku. Melihat tanda amaran, pemandu membandingkan berat kenderaannya dengan berat maksimum untuk jambatan. Jika kenderaan terlalu berat, pemandu mengambil laluan pintasan. Jabatan pengangkutan, pertama, membolehkan pemandu lori menukar laluan mereka jika perlu, kedua, memberi amaran kepada pemandu tentang bahaya di jalan utama, dan ketiga, memberi amaran kepada pemandu bahawa jambatan itu tidak boleh digunakan dalam keadaan tertentu. Keupayaan untuk mencegah dan menyelesaikan situasi luar biasa dalam program, membenarkan ia terus berjalan, adalah satu sebab untuk menggunakan pengecualian dalam Java. Mekanisme pengecualian juga membolehkan anda melindungi kod (API) anda daripada penggunaan yang tidak wajar dengan mengesahkan (menyemak) sebarang input. Sekarang bayangkan anda adalah bahagian pengangkutan untuk seketika. Pertama, anda perlu mengetahui tempat di mana pemandu boleh menjangkakan masalah. Kedua, anda perlu membuat dan memasang tanda amaran. Dan akhirnya, anda perlu menyediakan lencongan jika masalah timbul di laluan utama. Di Jawa, mekanisme pengecualian berfungsi dengan cara yang sama. Semasa pembangunan, kami menggunakan blok percubaan untuk membina "halangan pengecualian" di sekeliling bahagian kod berbahaya, kami menyediakan "laluan sandaran" menggunakan tangkapan {}blok, dan kami menulis kod yang sepatutnya dijalankan walau apa pun dalam blok {} akhirnya . Jika kami tidak dapat menyediakan "laluan sandaran" atau kami ingin memberi pengguna hak untuk memilih, kami mesti sekurang-kurangnya memberi amaran kepadanya tentang bahaya. kenapa? Bayangkan kemarahan seorang pemandu yang, tanpa melihat satu tanda amaran, sampai ke jambatan kecil yang tidak dapat dilaluinya! Dalam pengaturcaraan, semasa menulis kelas dan kaedah kami, kami tidak selalu dapat meramalkan cara ia boleh digunakan oleh pembangun lain. Akibatnya, kami tidak dapat meramalkan cara yang betul 100% untuk menyelesaikan situasi yang luar biasa. Walau bagaimanapun, adalah cara yang baik untuk memberi amaran kepada orang lain tentang kemungkinan situasi luar biasa. Mekanisme pengecualian Java membolehkan kami melakukan ini dengan lontarankata kunci — pada dasarnya pengisytiharan bahawa tingkah laku umum kaedah kami termasuk membuang pengecualian. Oleh itu, sesiapa yang menggunakan kaedah itu tahu dia harus menulis kod untuk mengendalikan pengecualian.

Memberi amaran kepada orang lain tentang "masalah"

Jika anda tidak merancang untuk mengendalikan pengecualian dalam kaedah anda, tetapi ingin memberi amaran kepada orang lain bahawa pengecualian mungkin berlaku, 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 membolehkan penggunanya melaksanakan logik pengendalian pengecualian mereka sendiri. Selepas lontaran, kami menentukan jenis pengecualian yang dilemparkan. Ini biasanya turun dari kelas Exception Java . Memandangkan Java ialah bahasa berorientasikan objek, semua pengecualian adalah objek dalam Java.

Hierarki pengecualian

Apabila ralat berlaku semasa program sedang berjalan, JVM mencipta objek jenis yang sesuai daripada hierarki pengecualian Java — satu set kemungkinan pengecualian yang turun daripada nenek moyang yang sama — kelas Throwable . Kami boleh membahagikan situasi masa jalan yang luar biasa kepada dua kumpulan:

1. Situasi di mana program tidak dapat pulih dan meneruskan operasi biasa.
2. Situasi di mana pemulihan adalah mungkin.

Kumpulan pertama termasuk situasi yang melibatkan pengecualian yang turun daripada kelas Ralat . Ini adalah ralat yang berlaku akibat kerosakan JVM, limpahan memori atau kegagalan sistem. Mereka biasanya menunjukkan masalah serius yang tidak boleh diperbaiki oleh perisian. Di Jawa, kemungkinan pengecualian tersebut tidak disemak oleh pengkompil, jadi ia dikenali sebagai pengecualian tidak ditanda. Kumpulan ini juga termasuk RuntimeExceptions, yang merupakan pengecualian yang turun daripada Exceptionkelas dan dijana oleh JVM pada masa larian. Mereka sering disebabkan oleh ralat pengaturcaraan. Pengecualian ini juga tidak ditanda (tidak ditanda) pada masa penyusunan, jadi anda tidak perlu menulis kod untuk mengendalikannya. Kumpulan kedua termasuk situasi luar biasa yang boleh diramalkan apabila anda menulis program (dan oleh itu anda harus menulis kod untuk mengendalikannya). Pengecualian sedemikian dipanggil pengecualian yang diperiksa. Apabila bercakap tentang pengecualian, kebanyakan kerja pembangun Java mengendalikan situasi sedemikian.

Mencipta pengecualian

Apabila program dijalankan, pengecualian dijana sama ada oleh JVM atau secara manual menggunakan pernyataan lontaran . Apabila ini berlaku, objek pengecualian dicipta dalam ingatan, aliran utama program terganggu, dan pengendali pengecualian JVM cuba mengendalikan pengecualian.

Pengendalian pengecualian

Dalam Java, kami mencipta blok kod di mana kami menjangkakan keperluan untuk pengendalian pengecualian menggunakan binaan try{}catch , cuba{}catch{}akhirnya dan cuba{}akhirnya{} binaan. Apabila pengecualian dilemparkan dalam blok percubaan , JVM mencari pengendali pengecualian yang sesuai dalam blok tangkapan seterusnya . Jika blok tangkapan mempunyai pengendali pengecualian yang diperlukan, kawalan beralih kepadanya. Jika tidak, maka JVM melihat lebih jauh ke bawah rantaian blok tangkapan sehingga pengendali yang sesuai ditemui. Selepas melaksanakan blok tangkapan , kawalan dipindahkan ke blok akhirnya pilihan . Jika tangkapan yang sesuaiblok tidak dijumpai, kemudian JVM menghentikan program dan memaparkan surih tindanan (timbunan semasa panggilan kaedah), selepas mula-mula melaksanakan blok akhirnya jika ia wujud. Contoh pengendalian 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 kaedah 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 mana-mana strim dan membebaskan sebarang sumber yang dibuka/diperuntukkan dalam blok percubaan . Walau bagaimanapun, semasa menulis program, tidak selalu mungkin untuk menjejaki penutupan semua sumber. Untuk menjadikan kehidupan kita lebih mudah, pembangun Java menawarkan binaan cuba-dengan-sumber , yang secara automatik menutup sebarang sumber yang dibuka dalam blok percubaan . Contoh pertama kami boleh ditulis semula 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;
}

Terima kasih kepada keupayaan Java yang diperkenalkan dalam versi 7, kami juga boleh menggabungkan menangkap pengecualian heterogen ke dalam satu blok, menjadikan kod lebih padat dan boleh 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;
}

Garisan bawah

Menggunakan pengecualian dalam Java membolehkan anda menjadikan program anda lebih mantap dengan mencipta "laluan sandaran", gunakan blok tangkapan untuk memisahkan kod utama daripada kod pengendalian pengecualian, dan gunakan lontaran untuk mengalihkan tanggungjawab pengendalian pengecualian kepada sesiapa sahaja yang menggunakan kaedah anda.