1. Pendahuluan
Cobalah ... Tangkap ... Akhirnya mungkin merupakan kalimat yang akrab dengan semua orang, dan rasanya sangat mudah digunakan, dan tampaknya secara logis mudah dimengerti. Namun, "pembelajaran" yang saya alami secara pribadi mengatakan kepada saya bahwa hal ini tidak sesederhana dan patuh seperti yang saya bayangkan. Tidak percaya? Lalu lihat kode di bawah ini, apa hasilnya setelah dieksekusi? Jangan melihat jawabannya ke belakang, Anda juga tidak mengizinkan kode dieksekusi untuk melihat jawaban yang sebenarnya. Jika jawaban Anda benar, maka Anda tidak perlu membuang waktu membaca artikel ini.
tes paket; Public Class TestException {public testException () {} boolean testex () melempar Exception {boolean ret = true; coba {ret = testex1 (); } catch (Exception e) {System.out.println ("TestEx, Catch Exception"); ret = false; lempar e; } akhirnya {System.out.println ("testex, akhirnya; value return =" + ret); Return Ret; }} boolean testex1 () melempar pengecualian {boolean ret = true; coba {ret = testex2 (); if (! ret) {return false; } System.out.println ("TestEx1, di akhir coba"); Return Ret; } catch (Exception e) {System.out.println ("TestEx1, Catch Exception"); ret = false; lempar e; } akhirnya {System.out.println ("testex1, akhirnya; value return =" + ret); Return Ret; }} boolean testex2 () melempar pengecualian {boolean ret = true; coba {int b = 12; int c; untuk (int i = 2; i> = -2; i--) {c = b / i; System.out.println ("i =" + i); } return true; } catch (Exception e) {System.out.println ("TestEx2, Catch Exception"); ret = false; lempar e; } akhirnya {System.out.println ("testex2, akhirnya; return value =" + ret); Return Ret; }} public static void main (string [] args) {testException testException1 = testException baru (); coba {testException1.testex (); } catch (Exception e) {E.PrintStackTrace (); }}} Apa jawaban Anda? Apakah itu jawabannya di bawah ini?
i = 2
i = 1
testex2, tangkap pengecualian
testex2, akhirnya; nilai pengembalian = false
testex1, tangkap pengecualian
testex1, akhirnya; nilai pengembalian = false
testex, tangkap pengecualian
testex, akhirnya; nilai pengembalian = false
Jika jawaban Anda benar -benar seperti yang disebutkan di atas, maka Anda salah. ^_^, maka saya sarankan Anda membaca artikel ini dengan cermat atau menggunakan kode di atas untuk memodifikasi, mengeksekusi, dan menguji sesuai dengan berbagai situasi. Anda akan menemukan bahwa ada banyak hal yang tidak sesederhana yang dibayangkan semula. Sekarang Publikasikan Jawaban yang Benar:
i = 2
i = 1
testex2, tangkap pengecualian
testex2, akhirnya; nilai pengembalian = false
testex1, akhirnya; nilai pengembalian = false
testex, akhirnya; nilai pengembalian = false
Catatan:
Akhirnya blok pernyataan tidak boleh muncul, pengembalian harus muncul. Pengembalian ret di atas lebih disukai pernyataan lain untuk menangani logika yang relevan.
2. Pengecualian Java
Pengecualian mengacu pada berbagai situasi yang terjadi secara tak terduga, seperti: File tidak ditemukan, kegagalan koneksi jaringan, parameter ilegal, dll. Pengecualian adalah peristiwa yang terjadi selama menjalankan program dan mengganggu aliran instruksi normal. Java menggambarkan berbagai pengecualian melalui banyak subclass dari kelas yang dapat dilemparkan di API. Oleh karena itu, pengecualian Java adalah objek, contoh subkelas yang dapat dilemparkan, menggambarkan kondisi kesalahan yang muncul dalam pengkodean. Ketika suatu kondisi dihasilkan, kesalahan akan melempar pengecualian.
Diagram Hirarki Kelas Pengecualian Java:
Gambar 1 Diagram Hirarki Kelas Pengecualian Java
Di Java, semua pengecualian memiliki nenek moyang yang sama, dapat dilemparkan (dapat dilempar). Throwable Menentukan kesamaan dari setiap masalah yang dapat ditransmisikan melalui aplikasi Java dalam kode dengan mekanisme propagasi pengecualian.
Throwable: Ada dua subclass penting: pengecualian dan kesalahan. Keduanya adalah subclass penting untuk penanganan pengecualian Java, dan masing -masing berisi sejumlah besar subclass.
Kesalahan: Kesalahan yang tidak dapat ditangani oleh program, menunjukkan masalah serius dalam menjalankan aplikasi. Sebagian besar kesalahan tidak terkait dengan tindakan yang dilakukan oleh penulis kode, tetapi mewakili masalah dengan JVM (Java Virtual Machine) ketika kode dijalankan. Misalnya, mesin virtual Java menjalankan kesalahan (virtual machineerror), dan outofmemoryError akan muncul ketika JVM tidak lagi memiliki sumber daya memori yang diperlukan untuk melanjutkan operasi. Ketika pengecualian ini terjadi, Java Virtual Machine (JVM) umumnya memilih untuk mengakhiri utas.
Kesalahan ini menunjukkan bahwa kegagalan terjadi ketika mesin virtual itu sendiri, atau ketika mesin virtual mencoba untuk menjalankan aplikasi, seperti kesalahan menjalankan mesin virtual Java (virtual machineError), kesalahan definisi kelas (noclassdeffounderror), dll. Kebanyakan kesalahan yang diizinkan di luar kendali dan pemrosesan kemampuan aplikasi, dan sebagian besar dari mereka. Untuk aplikasi yang dirancang dengan baik, bahkan jika kesalahan terjadi, itu pada dasarnya tidak mencoba untuk menangani pengecualian yang disebabkannya. Di Java, kesalahan dijelaskan oleh subclass of error.
Pengecualian: Pengecualian yang dapat ditangani oleh program itu sendiri.
Kelas pengecualian memiliki subclass penting, runtimeException. Kelas RunimeException dan subclass -nya mewakili kesalahan yang ditimbulkan oleh "Operasi JVM Umum". Misalnya, jika Anda mencoba menggunakan referensi objek nol, pembagi nol atau array di luar batas, pengecualian runtime (nullpointerException, ArithMeticException) dan ArrayIndexoutOfBoundException masing -masing dinaikkan.
Catatan: Perbedaan antara pengecualian dan kesalahan: Pengecualian dapat ditangani oleh program itu sendiri, tetapi kesalahan tidak dapat ditangani.
Secara umum, pengecualian Java (termasuk pengecualian dan kesalahan) dibagi menjadi pengecualian yang diperiksa dan pengecualian yang tidak dicentang.
Pengecualian dapat diperiksa (pengecualian yang harus ditangani oleh kompiler): mudah terjadi dan pengecualian yang masuk akal dan toleran ketika program yang benar berjalan. Meskipun pengecualian yang dapat diperiksa adalah kondisi abnormal, kejadiannya dapat diprediksi sampai batas tertentu, dan begitu kondisi abnormal seperti itu terjadi, ia harus ditangani dengan cara tertentu.
Kecuali untuk runtimeException dan subclass -nya, kelas pengecualian lainnya dan subclass mereka adalah pengecualian yang dapat diperiksa. Karakteristik dari pengecualian ini adalah bahwa kompiler Java akan memeriksanya, yaitu, ketika pengecualian seperti itu dapat terjadi dalam program, baik menangkapnya dengan pernyataan mencoba-tangkapan atau melemparkannya dengan klausa lemparan, jika tidak, kompilasi tidak akan lewat.
Pengecualian yang tidak dapat diperiksa (pengecualian bahwa kompiler tidak memerlukan pembuangan paksa): termasuk pengecualian runtime (runtimeException dan subclass -nya) dan kesalahan (kesalahan).
Pengecualian Pengecualian ini dibagi menjadi dua kategori: pengecualian runtime dan pengecualian non-runtime (pengecualian kompilasi). Pengecualian ini harus ditangani sebanyak mungkin dalam program.
Pengecualian Runtime: Mereka semua adalah kelas RuntimeException dan pengecualian subkelasnya, seperti NullpointerException (NULL POINTER ECPECTION), IndexOutOfBoundSException (Subscript Out-of-Bounds Exception), dll. Pengecualian ini tidak memeriksa pengecualian, dan Anda dapat memilih untuk menangkap dan memprosesnya dalam program, atau Anda tidak dapat menangani mereka. Pengecualian ini umumnya disebabkan oleh kesalahan logika program, dan program harus menghindari pengecualian sebanyak mungkin dari perspektif logis.
Karakteristik pengecualian runtime adalah bahwa kompiler Java tidak akan memeriksanya. Dengan kata lain, ketika pengecualian seperti itu dapat terjadi dalam program, bahkan jika tidak ditangkap dengan pernyataan mencoba-tangkapan dan dilemparkan dengan klausa lemparan, itu akan dikompilasi dan disahkan.
Pengecualian Non-Runtime (Pengecualian Kompilasi): adalah pengecualian selain runimeexception, dan termasuk dalam kelas pengecualian dan subkelasnya dalam hal jenis. Dari perspektif sintaks program, itu adalah pengecualian yang harus diproses. Jika tidak diproses, program tidak dapat dikompilasi dan dilewati. Seperti ioException, sqlexception, dll., Dan pengecualian pengecualian yang ditentukan pengguna, secara umum, tidak ada pengecualian pemeriksaan khusus yang diperiksa.
3. Mekanisme Penanganan Pengecualian
Dalam aplikasi Java, mekanisme penanganan pengecualian adalah: melempar pengecualian dan menangkap pengecualian.
Lempar pengecualian: Ketika kesalahan terjadi dalam suatu metode dan meningkatkan pengecualian, metode ini membuat objek pengecualian dan mengirimkannya ke sistem runtime. Objek pengecualian berisi informasi pengecualian seperti jenis pengecualian dan status program ketika pengecualian terjadi. Sistem runtime bertanggung jawab untuk menemukan dan menjalankan kode untuk menangani pengecualian.
Catch Exception: Setelah metode ini melempar pengecualian, sistem runtime akan beralih untuk mencari penangan pengecualian yang sesuai. Penangan pengecualian potensial adalah kumpulan metode yang tetap ada di tumpukan panggilan saat pengecualian terjadi. Ketika jenis pengecualian yang dapat ditangani oleh prosesor pengecualian konsisten dengan tipe pengecualian yang dilemparkan oleh metode ini, itu adalah prosesor pengecualian yang sesuai. Sistem runtime dimulai dengan metode di mana pengecualian terjadi, dan kemudian melihat kembali metode pada tumpukan panggilan secara bergantian sampai menemukan metode yang berisi penangan pengecualian yang sesuai dan menjalankannya. Ketika sistem runtime melintasi tumpukan panggilan dan tidak menemukan penangan pengecualian yang sesuai, sistem runtime berakhir. Pada saat yang sama, itu berarti penghentian program Java.
Untuk pengecualian runtime, kesalahan atau pengecualian yang terdeteksi, metode penanganan pengecualian yang diperlukan oleh teknologi Java berbeda.
Karena pengecualian runtime yang tidak terdeteksi, untuk mengimplementasikan aplikasi secara lebih masuk akal dan mudah, Java menetapkan bahwa pengecualian runtime akan secara otomatis dilemparkan oleh sistem runtime Java, yang memungkinkan aplikasi untuk mengabaikan pengecualian runtime.
Untuk kesalahan yang mungkin terjadi selama operasi metode, Java memungkinkan metode untuk tidak melempar deklarasi apa pun ketika metode tidak ditangkap. Karena sebagian besar pengecualian kesalahan adalah situasi yang tidak akan pernah diizinkan terjadi, dan juga pengecualian yang tidak boleh ditangkap oleh aplikasi yang masuk akal.
Untuk semua pengecualian yang dapat diperiksa, Java menetapkan bahwa metode harus ditangkap, atau dinyatakan di luar metode lemparan. Artinya, ketika suatu metode memilih untuk tidak menangkap pengecualian yang dapat diperiksa, ia harus menyatakan bahwa pengecualian akan dilemparkan.
Metode yang dapat menangkap pengecualian membutuhkan penyediaan jenis penangan pengecualian yang sesuai. Pengecualian yang tertangkap dapat disebabkan oleh pengecualian yang diangkat dan dilemparkan oleh pernyataannya sendiri, atau pengecualian yang dilemparkan oleh metode yang dipanggil atau sistem runtime Java, dll. Dengan kata lain, pengecualian yang dapat ditangkap metode harus menjadi pengecualian yang dilemparkan oleh kode Java di suatu tempat. Sederhananya, pengecualian selalu dilemparkan terlebih dahulu dan kemudian ditangkap.
Kode Java apa pun dapat melempar pengecualian, seperti: kode yang ditulis sendiri, kode dari paket lingkungan pengembangan Java, atau sistem runtime Java. Tidak peduli siapa itu, Anda bisa melempar pengecualian melalui pernyataan lemparan Java.
Pengecualian apa pun yang dilemparkan dari metode ini harus digunakan dengan klausa lemparan.
Pengecualian tangkapan dicapai melalui pernyataan mencoba-tangkapan atau pernyataan mencoba-tangkapan akhir.
Secara umum, Java menetapkan bahwa pengecualian yang dapat diperiksa harus ditangkap atau dinyatakan dilemparkan. Memungkinkan untuk mengabaikan runtimeException dan kesalahan yang tidak dicentang.
3.1 Tangkap Pengecualian: Coba, tangkap dan akhirnya
1. Pernyataan Catch
Di Java, pengecualian ditangkap oleh pernyataan mencoba-tangkapan. Bentuk sintaksisnya adalah:
coba {// kode program di mana pengecualian dapat terjadi} catch (type1 id1) {// tangkap dan berurusan dengan tipe pengecualian yang dilemparkan oleh coba type1} catch (type2 id2) {// tangkap dan berurusan dengan tipe pengecualian yang dilemparkan oleh coba type2}Sepasang kawat gigi setelah kata kunci mencoba membungkus sepotong kode yang mungkin memiliki pengecualian, yang disebut area pemantauan. Jika pengecualian terjadi selama metode Java selama berjalan, objek pengecualian dibuat. Lemparkan pengecualian di luar area pemantauan, dan sistem runtime Java mencoba menemukan klausul tangkapan yang cocok untuk menangkap pengecualian. Jika ada klausa tangkapan yang cocok, jalankan kode penanganan pengecualian dan pernyataan mencoba-tangkapan berakhir.
Prinsip pencocokan adalah: jika objek pengecualian yang dilemparkan milik kelas pengecualian dari klausa tangkapan atau milik subkelas dari kelas pengecualian, dianggap bahwa objek pengecualian yang dihasilkan cocok dengan jenis pengecualian yang ditangkap oleh blok tangkapan.
Contoh 1 Tangkap Pengecualian "Dividter is 0" yang dilemparkan oleh pernyataan lemparan.
Public Class TestException {public static void main (string [] args) {int a = 6; int b = 0; coba {// coba area pemantauan jika (b == 0) lempar arithmeticException baru (); // lempar pengecualian melalui throw pernyataan system.out.println ("Nilai a/ b adalah:" + a/ b); } catch (ArithMeticException e) {// Catch Catch Exception System.out.println ("Program ini memiliki pengecualian, dan variabel B tidak dapat 0."); } System.out.println ("Program berakhir normal."); }}Hasil Menjalankan: Program memiliki pengecualian dan variabel B tidak dapat 0.
Program berakhir secara normal.
Contoh 1 Di area cobalah pemantauan, gunakan Pernyataan IF untuk menilai. Ketika kondisi kesalahan "Divider is 0" ditetapkan, pengecualian arithmeticException dibuat, dan pernyataan lemparan melempar pengecualian ke sistem runtime Java. Sistem menemukan tangkapan penangan pengecualian yang cocok dan menjalankan kode penanganan pengecualian yang sesuai. Cetak "Program ini memiliki pengecualian, dan variabel B tidak dapat 0." Pernyataan mencoba-tangkapan berakhir dan melanjutkan aliran program.
Faktanya, ArithmeticException seperti "Divider is 0" adalah subclass dari runtimexception. Pengecualian runtime akan secara otomatis dilemparkan oleh sistem runtime, dan tidak perlu menggunakan pernyataan lemparan.
Contoh 2: Tangkap pengecualian arithmeticException yang disebabkan oleh "pembagi adalah 0" secara otomatis melempar selama sistem runtime.
public static void main (string [] args) {int a = 6; int b = 0; coba {System.out.println ("Nilai A / B adalah:" + a / b); } catch (ArithMeticException e) {System.out.println ("Program ini memiliki pengecualian, dan variabel B tidak dapat 0."); } System.out.println ("Program berakhir normal."); }}Hasil Menjalankan: Program memiliki pengecualian dan variabel B tidak dapat 0.
Program berakhir secara normal.
Pernyataan dalam Contoh 2:
System.out.println ("Nilai A/B adalah:" + A/B);Kesalahan "Divider is 0" dihasilkan selama runtime, dan pengecualian ArithmeticException dinaikkan. Sistem runtime membuat objek pengecualian dan melempar area pemantauan, sebaliknya cocok dengan tangkapan penangan pengecualian yang sesuai, dan menjalankan kode penanganan pengecualian yang sesuai.
Karena biaya pengecekan pengecualian runtime jauh lebih besar daripada manfaat menangkap pengecualian, pengecualian runtime tidak dapat dideteksi. Kompiler Java memungkinkan untuk mengabaikan pengecualian runtime, dan metode tidak dapat menangkap atau menyatakan pengecualian runtime melempar.
Contoh 3: Tidak ada tangkapan atau menyatakan bahwa pengecualian runtime dilemparkan.
Public Class TestException {public static void main (string [] args) {int a, b; a = 6; b = 0; // nilai pembagi B adalah 0 System.out.println (A / B); }}Hasil Menjalankan:
Pengecualian di Thread "Main" java.lang.arithmeticexception: / by nol
di test.testException.main (testException.java:8)
Contoh 4 Program ini mungkin memiliki pengecualian dari Divisor 0 dan pengecualian subskrip array di luar batas.
Public Class TestException {public static void main (string [] args) {int [] intarray = new int [3]; coba {untuk (int i = 0; i <= intarray.length; i ++) {intarray [i] = i; System.out.println ("intarray [" + i + "] =" + intarray [i]); System.out.println ("IntArray [" + i + "] Modul" + (i - 2) + "Nilai:" + intarray [i] % (i - 2)); }} catch (arrayIndexOutOfBoundSException e) {System.out.println ("IntArray Array Subscript Out-of-Bounds Exception."); } catch (ArithMeticException e) {System.out.println ("Pengecualian Divisor 0."); } System.out.println ("Program berakhir secara normal."); }}Hasil Menjalankan:
intarray [0] = 0
IntArray [0] Nilai Modul-2: 0
intarray [1] = 1
Nilai intarray [1] modulo-1: 0
intarray [2] = 2
Pengecualian pembagi 0.
Program berakhir secara normal.
Contoh 5 Program ini dapat mengalami pengecualian divisor 0, dan pengecualian subskrip array juga dapat terjadi. Selama program berjalan, tipe pengecualian ArithMeticException terlebih dahulu, sehingga pernyataan tangkapan yang cocok dieksekusi:
Catch (ArithMeticException e) {System.out.println ("Pengecualian Divisor 0."); }Perlu dicatat bahwa begitu tangkapan tangkapan menangkap jenis pengecualian yang cocok, itu akan memasukkan kode penanganan pengecualian. Setelah pemrosesan selesai, itu berarti bahwa seluruh pernyataan mencoba-tangkapan berakhir. Klausa tangkapan lainnya tidak lagi memiliki kesempatan untuk mencocokkan dan menangkap jenis pengecualian.
Java menggambarkan jenis pengecualian melalui kelas pengecualian, dan hierarki kelas pengecualian ditunjukkan pada Gambar 1. Untuk program pengecualian dengan klausa tangkapan berganda, Anda harus mencoba untuk menempatkan klausa tangkapan yang menangkap kelas pengecualian yang mendasarinya, dan mencoba untuk meletakkan klausa tangkapan yang menangkap kelas pengecualian tingkat tinggi nanti. Kalau tidak, klausa tangkapan yang menangkap kelas pengecualian yang mendasarinya kemungkinan akan diblokir.
Kelas Pengecualian RunimeException mencakup berbagai pengecualian umum saat runtime, dan kelas ArithMeticException dan kelas ArrayIndexoutOfBoundSexception keduanya adalah subkelas. Oleh karena itu, klausa tangkapan dari kelas pengecualian runimeException harus ditempatkan di ujungnya, jika tidak, ia dapat memblokir penanganan pengecualian berikutnya atau menyebabkan kesalahan kompilasi.
2. Pernyataan coba-akhir
Pernyataan TRY-Catch juga dapat mencakup bagian ketiga, yang merupakan klausa akhirnya. Ini menunjukkan apa yang harus dieksekusi terlepas dari apakah suatu pengecualian terjadi atau tidak. Bentuk sintaks umum dari pernyataan try-catch-final adalah:
coba {// kode program yang mungkin terjadi pengecualian} catch (type1 id1) {// menangkap dan memproses tipe pengecualian yang dilemparkan oleh coba type1} catch (type2 id2) {// tangkap dan proses tipe pengecualian yang dilemparkan oleh try type2} akhirnya {// blok pernyataan yang akan dieksekusi terlepas dari apakah pengecualian terjadiContoh 6 Penangan Pengecualian dengan Klausul Akhirnya.
Public Class TestException {public static void main (string args []) {int i = 0; Salam String [] = {"Halo dunia!", "Halo dunia !!", "Halo Dunia !!!" }; while (i <4) {coba {// Berikan perhatian khusus pada desain variabel kontrol loop I untuk menghindari menyebabkan loops tak terbatas System.out.println (salam [i ++]); } catch (arrayIndExoutOfBoundSexception e) {System.out.println ("ArraySubscript out-of-Bounds Exception"); } akhirnya {System.out.println ("--------------------------"); }}}}Hasil Menjalankan:
Halo dunia!
--------------------------------
Halo dunia !!
--------------------------------
Halo Dunia !!!
--------------------------------
Array Subscript Out of Bounds Exception
--------------------------------
Dalam Contoh 6, silakan memberi perhatian khusus pada desain blok pernyataan dalam klausa coba. Jika desainnya adalah sebagai berikut, loop mati akan terjadi. Jika dirancang sebagai:
coba {System.out.println (Salam [i]); i ++; }ringkasan:
Coba Blok: Digunakan untuk menangkap pengecualian. Setelah itu, nol atau lebih blok tangkapan dapat dihubungkan. Jika tidak ada blok tangkapan, itu harus diikuti oleh blok akhirnya.
Catch Block: Digunakan untuk menangani pengecualian yang ditangkap oleh mencoba.
Akhirnya Blok: Pernyataan di blok akhirnya akan dieksekusi terlepas dari apakah pengecualian ditangkap atau diproses. Saat pernyataan pengembalian ditemui di blok coba atau blok tangkapan, blok pernyataan akhirnya akan
Mengeksekusi sebelum metode kembali. Dalam 4 kasus khusus berikut, akhirnya blok tidak akan dieksekusi:
1) Pengecualian terjadi di blok pernyataan akhirnya.
2) Gunakan System.exit () dalam kode sebelumnya untuk keluar dari program.
3) Benang tempat program berada dies.
4) Matikan CPU.
3. Peraturan mencoba-akhir (aturan tata bahasa untuk pernyataan penanganan pengecualian):
1) Penangkapan atau akhirnya blok harus ditambahkan setelah mencoba. Setelah blok coba, tangkapan dan akhirnya blok dapat dihubungkan pada saat yang sama, tetapi setidaknya ada satu blok.
2) Urutan blok harus diikuti: Jika kode menggunakan kedua tangkapan dan akhirnya blok, blok tangkapan harus ditempatkan setelah blok coba.
3) Blok tangkapan terkait dengan jenis kelas pengecualian yang sesuai.
4) Blok percobaan mungkin memiliki beberapa blok tangkapan. Jika demikian, blok pencocokan pertama dieksekusi. Artinya, mesin virtual Java cocok dengan objek pengecualian yang dilemparkan aktual dengan tipe pengecualian yang dinyatakan oleh setiap blok kode tangkapan secara berurutan. Jika objek pengecualian adalah jenis pengecualian atau instance dari subkelasnya, blok kode tangkapan akan dieksekusi dan tidak ada blok kode tangkapan lain yang akan dieksekusi.
5) Struktur percobaan-tangkapan-akhir bersarang.
6) Dalam struktur percobaan-penutup-akhir, pengecualian dapat dilemparkan kembali.
7) Selain situasi berikut, eksekusi akhirnya berakhir: JVM berakhir sebelum waktunya (disebut System.Exit (int)); melempar pengecualian yang tidak ditangani di blok akhirnya; Komputer ditenagai, dipecat, atau diserang oleh virus.
4. Urutan eksekusi mencoba, menangkap, dan akhirnya blok pernyataan:
1) ketika percobaan tidak menangkap pengecualian: Pernyataan dalam blok pernyataan coba dieksekusi satu per satu, dan program akan melewatkan blok pernyataan tangkapan dan menjalankan blok pernyataan akhirnya dan pernyataan berikutnya;
2) Ketika coba menangkap pengecualian, blok pernyataan tangkapan tidak menangani pengecualian ini: Ketika pengecualian terjadi dalam sebuah pernyataan di blok pernyataan coba dan blok pernyataan tangkapan yang tidak menangani pengecualian ini, pengecualian akan dilemparkan ke JVM untuk diproses, dan pernyataan dalam blok pernyataan akhirnya masih akan dieksekusi, tetapi pernyataan setelah pernyataan akhirnya tidak akan dieksekusi;
3) Ketika sebuah mencoba menangkap pengecualian, blok pernyataan tangkapan akan menangani pengecualian ini: itu dieksekusi di blok pernyataan try secara berurutan. Ketika pengecualian terjadi ketika pengecualian terjadi dalam pernyataan tertentu, program akan melompat ke blok pernyataan tangkapan dan mencocokkannya satu per satu. Temukan pawang yang sesuai. Blok pernyataan tangkapan lainnya tidak akan dieksekusi. Dalam blok pernyataan coba, pernyataan setelah pengecualian terjadi tidak akan dieksekusi. Setelah blok pernyataan tangkapan dieksekusi, pernyataan dalam blok pernyataan akhirnya akan dieksekusi, dan akhirnya pernyataan setelah blok pernyataan akhirnya akan dieksekusi;
Ilustrasi eksekusi blok percobaan, tangkap, dan akhirnya pernyataan:
Gambar 2 mengilustrasikan eksekusi blok percobaan, tangkapan, dan akhirnya
3.2 Lemparkan Pengecualian
Kode Java apa pun dapat melempar pengecualian, seperti: kode yang ditulis sendiri, kode dari paket lingkungan pengembangan Java, atau sistem runtime Java. Tidak peduli siapa itu, Anda bisa melempar pengecualian melalui pernyataan lemparan Java. Pengecualian apa pun yang dilemparkan dari metode ini harus digunakan dengan klausa lemparan.
1. Melempar Lempar Pengecualian
Jika metode mungkin memiliki pengecualian tetapi tidak memiliki kemampuan untuk menangani pengecualian seperti itu, Anda dapat menggunakan klausa lemparan untuk menyatakan pengecualian yang dilemparkan pada deklarasi metode. Misalnya, mobil mungkin gagal saat berjalan, dan mobil itu sendiri tidak dapat menangani kegagalan ini, jadi biarkan pengemudi menghadapinya.
Pernyataan lemparan digunakan untuk mendeklarasikan jenis pengecualian untuk dilemparkan ketika metode didefinisikan. Jika jenis pengecualian dilemparkan, metode ini dinyatakan untuk melempar semua pengecualian. Beberapa pengecualian dapat dibagi menggunakan koma. Format sintaks dari pernyataan lemparan adalah:
MethodName melempar Exception1, Exception2, .., Exceptionn {} Lempar Setelah Metode Name Exception1, Exception2, ..., Exceptionn adalah daftar pengecualian yang akan dilemparkan. Ketika suatu metode melempar daftar pengecualian pengecualian, metode ini tidak akan menangani pengecualian dari tipe -tipe ini dan tipe subkelasnya, tetapi akan dilemparkan ke metode yang memanggil metode ini dan akan ditangani olehnya. Misalnya:
impor java.lang.Exception; Public Class TestException {static void pop () melempar negativearraysizeException {// tentukan metode dan lemparkan negativearraysizeException intuxt int [] arr = int int [-3]; // Buat array} public static void main (string [] args) {// Metode utama coba {// coba pernyataan menangani informasi pengecualian pop (); // Panggil metode pop ()} catch (negativearraysizeException e) {System.out.println ("Pengecualian yang dilemparkan oleh metode POP ()"); // informasi pengecualian output}}}Setelah melempar pengecualian ke penelepon menggunakan kata kunci lemparan, jika penelepon tidak ingin menangani pengecualian, Anda dapat terus melemparkannya, tetapi pada akhirnya harus ada penelepon yang dapat menangani pengecualian.
Metode POP tidak menangani pengecualian negativearraysizeException, tetapi ditangani oleh fungsi utama.
Aturan untuk melempar untuk melempar pengecualian:
1) Jika itu adalah pengecualian yang tidak terkendali, yaitu, kesalahan, runtimeException atau subclass mereka, Anda dapat menyatakan pengecualian yang akan dilemparkan tanpa menggunakan kata kunci lemparan, dan kompilasi masih akan berlalu dengan lancar, tetapi akan dilemparkan oleh sistem saat runtime.
2) Pengecualian yang diperiksa yang dapat dilemparkan dengan metode ini harus dinyatakan. Artinya, jika suatu metode mungkin memiliki pengecualian yang dapat diperiksa, itu akan ditangkap dengan pernyataan mencoba-tangkapan atau melemparkannya dengan deklarasi klausa lemparan, jika tidak itu akan menyebabkan kesalahan kompilasi.
3) Hanya ketika pengecualian dilemparkan, penelepon metode harus menangani atau melempar kembali pengecualian. Ketika metode penelepon tidak dapat menangani pengecualian, itu harus terus melemparkannya alih -alih menelannya utuh.
4) Metode panggilan harus mengikuti aturan penanganan dan deklarasi pengecualian yang dapat diperiksa. Jika metode ditimpa, pengecualian yang berbeda dari metode yang ditimpa tidak dapat dinyatakan. Pengecualian apa pun yang dinyatakan harus serupa atau subkelas dari pengecualian yang dinyatakan dengan metode yang ditimpa.
Misalnya:
void method1 () melempar ioException {} // legal // kesalahan kompilasi, ioException harus ditangkap atau dinyatakan untuk melempar void method2 () {method1 (); } // legal, menyatakan untuk melempar ioException void method3 () melempar ioException {method1 (); } // legal, menyatakan untuk melempar pengecualian, ioException adalah subkelas dari exception void method4 () melempar pengecualian {method1 (); } // legal, capture ioException void method5 () {try {Method1 (); } catch (ioException e) {...}} // Kesalahan kompilasi, Anda harus menangkap atau mendeklarasikan lemparan void method6 () {coba {method1 (); } catch (ioException e) {throw new Exception ();}} // legal, Deklarasi lempar void method7 () melempar pengecualian {coba {method1 (); } catch (ioException e) {lempar pengecualian baru ();}} Dasar untuk menentukan bahwa pengecualian dapat terjadi dalam metode adalah sebagai berikut:
1) Ada pernyataan lemparan dalam metode ini. Misalnya, blok kode tangkapan dari metode Method7 () di atas memiliki pernyataan lemparan.
2) Metode lain dipanggil, dan metode lain menggunakan klausa lemparan untuk menyatakan beberapa pengecualian untuk dilemparkan. Sebagai contoh, metode Method3 () memanggil metode Method1 (), dan metode Method1 () menyatakan bahwa iOException dilemparkan, sehingga iOException dapat terjadi dalam metode Method3 ().
2. Gunakan lemparan untuk melempar pengecualian
Throw selalu muncul di badan fungsi dan digunakan untuk melempar pengecualian tipe yang dapat dilempar. Program akan berakhir segera setelah pernyataan lemparan, pernyataan setelah itu tidak dapat dieksekusi, dan kemudian di semua blok percobaan yang memuatnya (mungkin dalam fungsi panggilan tingkat atas) mencari blok mencoba yang berisi klausa tangkapan yang cocok dengannya dari dalam ke luar.
Kita tahu bahwa pengecualian adalah objek contoh dari kelas pengecualian, dan kami dapat membuat objek instance dari kelas pengecualian untuk dilemparkan melalui pernyataan lemparan. Format sintaks dari pernyataan ini adalah:
Lempar nama pengecualian baru;
Misalnya, lempar objek pengecualian dari kelas IOException:
Lemparkan ioException baru;
Perlu dicatat bahwa hanya melempar objek instance yang dapat melempar kelas yang dapat dilempar atau subkelas. Operasi berikut salah:
lempar string baru ("pengecualian");Ini karena string bukanlah subclass dari kelas yang dapat dilemparkan.
Jika pengecualian cek dilemparkan, Anda juga harus menyatakan jenis pengecualian yang dapat dilemparkan metode dalam header metode. Penelepon metode ini juga harus memeriksa untuk menangani pengecualian yang dilemparkan.
Jika semua metode melempar lapisan pengecualian yang diperoleh, JVM pada akhirnya akan memprosesnya, dan pemrosesannya juga sangat sederhana, yaitu mencetak pesan pengecualian dan menumpuk informasi. Jika kesalahan atau runimeException dilemparkan, penelepon metode memiliki opsi untuk menangani pengecualian.
tes paket; impor java.lang.Exception; Public Class TestException {static int quotient (int x, int y) melempar myException {// tentukan metode untuk melempar pengecualian jika (y <0) {// Tentukan apakah parameter kurang dari 0 melempar myException baru ("pembagi tidak dapat berupa angka negatif"); // informasi pengecualian} return x/y; // nilai pengembalian} public static void main (string args []) {// Metode utama int a = 3; int b = 0; Coba {// Coba pernyataan berisi pernyataan yang mungkin memiliki pengecualian int result = quotient (a, b); // Metode Panggilan quoteent ()} catch (myException e) {// menangani kustom exception system.out.println (e.getMessage ()); // Informasi Pengecualian Output} Catch (ArithMeticException E) {// Tangani ArithMeticException Exception System.out.println ("PerceraiPs tidak bisa 0"); // output informasi prompt} catch (pengecualian e) {// menangani pengecualian lain System.out.println ("Pengecualian lain terjadi dalam program"); // output informasi prompt}}} kelas myException memperluas pengecualian {// buat pesan string kelas pengecualian khusus; // Tentukan string type variabel publik myException (string errorMessAgr) {// Parent Class Method Message = errorMessAgr; } public String getMessage () {// override getMessage () Metode kembali pesan; }}3.3 Rantai Pengecualian
1) jika hasil bagi (3, -1) dipanggil, pengecualian myException akan terjadi dan program akan ditransfer ke blok kode tangkapan (MyException e) untuk dieksekusi;
2) Jika hasil bagi (5,0) dipanggil, pengecualian ArithmeticException akan dinaikkan karena kesalahan "Divider is 0". Itu milik kelas pengecualian runtime dan secara otomatis dilemparkan oleh sistem runtime Java. Metode quotient () tidak menangkap pengecualian arithmeticException. Sistem runtime Java akan mencari metode utama di sepanjang metode panggilan panggilan dan mengunggah pengecualian yang dilemparkan ke penelepon metode quotient ():
hasil int = quotient (a, b); // Metode Panggilan Quotient ()
Karena pernyataan ini ada di area pemantauan cobalah, ArithmeticException dengan "Divider is 0" berlalu dilemparkan oleh sistem runtime java dan cocok dengan klausa tangkapan:
Catch (ArithMeticException E) {// Handle ArithMeticException Exception System.out.println ("Pembagi tidak bisa 0"); // output informasi prompt}Hasil pemrosesan adalah bahwa output "pembagi tidak bisa 0". Java, mekanisme pemrosesan yang melewati informasi pengecualian ke atas, membentuk rantai pengecualian.
Pengecualian yang dapat diperiksa yang dilemparkan oleh metode Java akan diteruskan ke metode panggilan dengan kemampuan pemrosesan berdasarkan tumpukan panggilan dan sepanjang hierarki panggilan metode, dan level tertinggi akan sampai metode utama. Jika pengecualian diteruskan ke metode utama, tetapi utama tidak memiliki kemampuan untuk menanganinya dan tidak melempar pengecualian melalui deklarasi lemparan, kesalahan kompilasi dapat terjadi.
3) Jika pengecualian lain terjadi, tangkap (pengecualian e) akan digunakan untuk menangkap. Since Exception is the parent class of all exception classes, if the catch (Exception e) code block is placed in front of the other two code blocks, the subsequent code blocks will never be executed, which makes no sense, so the order of catch statements cannot be replaced.
3.4 Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果cause 不存在或未知，则返回null。
getMeage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
5.Java常见异常
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException 数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
3. 其他
ClassCastException 类型转换异常类
ArrayStoreException 数组中包含不兼容的值抛出的异常
SQLException 操作数据库异常类
NoSuchFieldException 字段未找到异常
NoSuchMethodException 方法未找到抛出的异常
NumberFormatException 字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException 不允许访问某类异常
InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
6.自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。
在上面的“使用throw抛出异常”例子已经提到了。
Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.