1. บทนำ
ลอง…จับ…ในที่สุดก็อาจเป็นประโยคที่ทุกคนคุ้นเคยและรู้สึกง่ายมากที่จะใช้และดูเหมือนว่าจะเข้าใจได้ง่ายอย่างมีเหตุผล อย่างไรก็ตาม "การเรียนรู้" ที่ฉันมีประสบการณ์เป็นการส่วนตัวบอกฉันว่าสิ่งนี้ไม่ง่ายและเชื่อฟังอย่างที่ฉันจินตนาการไว้ ไม่เชื่อ? จากนั้นดูที่รหัสด้านล่างผลลัพธ์จะเป็นอย่างไรหลังจากดำเนินการ? อย่าดูคำตอบย้อนหลังและคุณไม่อนุญาตให้ใช้รหัสเพื่อดูคำตอบที่แท้จริง หากคำตอบของคุณถูกต้องคุณไม่ต้องเสียเวลาอ่านบทความนี้
การทดสอบแพ็คเกจ; Public Class TestException {Public TestException () {} Boolean Testex () โยนข้อยกเว้น {บูลีน ret = true; ลอง {ret = testex1 (); } catch (exception e) {system.out.println ("testex, catch exception"); ret = false; โยน e; } ในที่สุด {system.out.println ("testex, สุดท้าย; return value =" + ret); return ret; }} บูลีน testex1 () โยนข้อยกเว้น {บูลีน ret = true; ลอง {ret = testex2 (); if (! ret) {return false; } system.out.println ("testex1 ในตอนท้ายของการลอง"); return ret; } catch (exception e) {system.out.println ("testex1, catch exception"); ret = false; โยน e; } ในที่สุด {system.out.println ("testex1, สุดท้าย; return value =" + ret); return ret; }} บูลีน testex2 () พ่นข้อยกเว้น {บูลีน ret = true; ลอง {int b = 12; int c; สำหรับ (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; โยน e; } ในที่สุด {system.out.println ("testex2, สุดท้าย; return value =" + ret); return ret; }} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {testexception testexception1 = testException ใหม่ (); ลอง {testexception1.testex (); } catch (exception e) {e.printstacktrace (); - คำตอบของคุณคืออะไร? เป็นคำตอบด้านล่างหรือไม่?
i = 2
i = 1
testex2, จับข้อยกเว้น
testex2 ในที่สุด; return value = false
testex1, จับข้อยกเว้น
testex1 ในที่สุด; return value = false
testex จับข้อยกเว้น
testex ในที่สุด; return value = false
หากคำตอบของคุณเป็นไปตามที่กล่าวไว้ข้างต้นคุณก็ผิด ^_^จากนั้นฉันขอแนะนำให้คุณอ่านบทความนี้อย่างระมัดระวังหรือใช้รหัสข้างต้นเพื่อแก้ไขดำเนินการและทดสอบตามสถานการณ์ต่างๆ คุณจะพบว่ามีหลายสิ่งหลายอย่างที่ไม่ง่ายอย่างที่จินตนาการไว้ ตอนนี้เผยแพร่คำตอบที่ถูกต้อง:
i = 2
i = 1
testex2, จับข้อยกเว้น
testex2 ในที่สุด; return value = false
testex1 ในที่สุด; return value = false
testex ในที่สุด; return value = false
บันทึก:
ในที่สุดบล็อกคำสั่งไม่ควรปรากฏขึ้นกลับควรปรากฏขึ้น RET RET RET ด้านบนควรใช้คำสั่งอื่นเพื่อจัดการตรรกะที่เกี่ยวข้อง
2. ข้อยกเว้น Java
ข้อยกเว้นอ้างถึงสถานการณ์ต่าง ๆ ที่เกิดขึ้นโดยไม่คาดคิดเช่น: ไม่พบไฟล์, ความล้มเหลวในการเชื่อมต่อเครือข่าย, พารามิเตอร์ที่ผิดกฎหมาย ฯลฯ ข้อยกเว้นคือเหตุการณ์ที่เกิดขึ้นในระหว่างการทำงานของโปรแกรมและรบกวนการไหลของคำสั่งปกติ Java อธิบายข้อยกเว้นต่าง ๆ ผ่านคลาสย่อยของชั้นเรียนที่สามารถโยนได้ใน API ดังนั้นข้อยกเว้นของ Java คือวัตถุอินสแตนซ์ของคลาสย่อยที่โยนได้อธิบายเงื่อนไขข้อผิดพลาดที่ปรากฏในการเข้ารหัส เมื่อมีการสร้างเงื่อนไขข้อผิดพลาดจะทำให้เกิดข้อยกเว้น
แผนภาพลำดับชั้นของคลาส Java Exception:
รูปที่ 1 แผนผังลำดับชั้นคลาส Java Exception
ใน Java ข้อยกเว้นทั้งหมดมีบรรพบุรุษร่วมกัน, โยนได้ (โยนได้) การโยนได้ระบุความธรรมดาของปัญหาใด ๆ ที่สามารถส่งผ่านแอปพลิเคชัน Java ในรหัสโดยกลไกการแพร่กระจายข้อยกเว้น
โยนได้: มีสองคลาสย่อยที่สำคัญ: ข้อยกเว้นและข้อผิดพลาด ทั้งสองเป็นคลาสย่อยที่สำคัญสำหรับการจัดการข้อยกเว้น Java และแต่ละชุดมีคลาสย่อยจำนวนมาก
ข้อผิดพลาด: ข้อผิดพลาดที่โปรแกรมไม่สามารถจัดการได้โดยระบุปัญหาร้ายแรงในการเรียกใช้แอปพลิเคชัน ข้อผิดพลาดส่วนใหญ่ไม่เกี่ยวข้องกับการกระทำที่ดำเนินการโดยผู้เขียนโค้ด แต่แสดงถึงปัญหากับ JVM (เครื่องเสมือน Java) เมื่อรหัสถูกเรียกใช้ ตัวอย่างเช่นเครื่องเสมือน Java เรียกใช้ข้อผิดพลาด (Virtual Machineerror) และ OutofMemoryError จะปรากฏขึ้นเมื่อ JVM ไม่ได้มีทรัพยากรหน่วยความจำอีกต่อไปในการดำเนินการต่อ เมื่อข้อยกเว้นเหล่านี้เกิดขึ้นเครื่องเสมือน Java (JVM) โดยทั่วไปเลือกที่จะยุติเธรด
ข้อผิดพลาดเหล่านี้บ่งชี้ว่าความล้มเหลวเกิดขึ้นเมื่อเครื่องเสมือนจริงหรือเมื่อเครื่องเสมือนพยายามเรียกใช้งานแอปพลิเคชันเช่นเครื่องเสมือน Java ที่ใช้งานข้อผิดพลาด (เครื่องจักรเสมือนจริง) ข้อผิดพลาดคำจำกัดความของคลาส สำหรับแอปพลิเคชันที่ออกแบบมาอย่างดีแม้ว่าจะเกิดข้อผิดพลาด แต่ก็ไม่ควรพยายามจัดการกับข้อยกเว้นที่เกิดขึ้น ใน Java ข้อผิดพลาดถูกอธิบายโดยคลาสย่อยของข้อผิดพลาด
ข้อยกเว้น: ข้อยกเว้นที่โปรแกรมสามารถจัดการได้
คลาสข้อยกเว้นมีคลาสย่อยที่สำคัญ RuntimeException คลาส RuntimeException และคลาสย่อยแสดงถึงข้อผิดพลาดที่เกิดขึ้นจาก "การดำเนินการ JVM ทั่วไป" ตัวอย่างเช่นหากคุณพยายามใช้การอ้างอิงวัตถุที่เป็นโมฆะศูนย์ตัวหารหรืออาร์เรย์เป็นศูนย์ยกเว้นรันไทม์ข้อยกเว้น (nullpointerexception, arithmeticexception) และ arrayIndexoutofboundException ตามลำดับ
หมายเหตุ: ความแตกต่างระหว่างข้อยกเว้นและข้อผิดพลาด: ข้อยกเว้นสามารถจัดการได้โดยโปรแกรมเอง แต่ไม่สามารถจัดการข้อผิดพลาดได้
โดยทั่วไปแล้วข้อยกเว้น Java (รวมถึงข้อยกเว้นและข้อผิดพลาด) จะถูกแบ่งออกเป็นข้อยกเว้นที่ตรวจสอบแล้วและข้อยกเว้นที่ไม่ได้ตรวจสอบ
สามารถตรวจสอบข้อยกเว้นได้ (ข้อยกเว้นที่ต้องจัดการโดยคอมไพเลอร์): มันง่ายที่จะเกิดขึ้นและมีข้อยกเว้นที่สมเหตุสมผลและอดทนเมื่อโปรแกรมที่ถูกต้องทำงาน แม้ว่าข้อยกเว้นที่ตรวจสอบได้นั้นเป็นเงื่อนไขที่ผิดปกติ แต่การเกิดขึ้นของมันสามารถคาดการณ์ได้ในระดับหนึ่งและเมื่อสภาพที่ผิดปกติเกิดขึ้นก็จะต้องจัดการในบางวิธี
ยกเว้น RuntimeException และคลาสย่อยของคลาสข้อยกเว้นอื่น ๆ และคลาสย่อยของพวกเขาเป็นข้อยกเว้นที่ตรวจสอบได้ทั้งหมด ลักษณะของข้อยกเว้นนี้คือคอมไพเลอร์ Java จะตรวจสอบนั่นคือเมื่อข้อยกเว้นดังกล่าวอาจเกิดขึ้นในโปรแกรมไม่ว่าจะจับกับคำสั่งลองจับหรือโยนมันด้วยประโยคการโยนมิฉะนั้นการรวบรวมจะไม่ผ่าน
ข้อยกเว้นที่ไม่สามารถตรวจสอบได้ (ข้อยกเว้นที่คอมไพเลอร์ไม่จำเป็นต้องมีการกำจัดบังคับ): รวมถึงข้อยกเว้นรันไทม์ (RuntimeException และคลาสย่อย) และข้อผิดพลาด (ข้อผิดพลาด)
ข้อยกเว้นข้อยกเว้นนี้แบ่งออกเป็นสองหมวดหมู่: ข้อยกเว้นรันไทม์และข้อยกเว้นที่ไม่ใช่ตามกฎหมาย (ข้อยกเว้นการรวบรวม) ข้อยกเว้นเหล่านี้ควรได้รับการจัดการให้มากที่สุดเท่าที่จะทำได้ในโปรแกรม
ข้อยกเว้นรันไทม์: พวกเขาทั้งหมดเป็นคลาส RuntimeException และข้อยกเว้น subclass ของมันเช่น nullpointerexception (ข้อยกเว้นตัวชี้ null), indexoutofboundsexception ข้อยกเว้นเหล่านี้โดยทั่วไปเกิดจากข้อผิดพลาดของลอจิกของโปรแกรมและโปรแกรมควรหลีกเลี่ยงข้อยกเว้นดังกล่าวมากที่สุดเท่าที่จะทำได้จากมุมมองเชิงตรรกะ
ลักษณะของข้อยกเว้นรันไทม์คือคอมไพเลอร์ Java จะไม่ตรวจสอบ กล่าวคือเมื่อข้อยกเว้นดังกล่าวอาจเกิดขึ้นในโปรแกรมแม้ว่าจะไม่ได้ถูกจับด้วยคำสั่งลองจับและโยนด้วยประโยคการโยนมันจะถูกรวบรวมและผ่าน
ข้อยกเว้นที่ไม่ใช่ตามกฎหมาย (ข้อยกเว้นการรวบรวม): เป็นข้อยกเว้นนอกเหนือจาก RuntimeException และเป็นของคลาส Exception และคลาสย่อยในแง่ของประเภท จากมุมมองของไวยากรณ์ของโปรแกรมมันเป็นข้อยกเว้นที่ต้องดำเนินการ หากไม่ได้ประมวลผลโปรแกรมจะไม่สามารถรวบรวมและผ่านได้ เช่น IOException, Sqlexception ฯลฯ และข้อยกเว้นข้อยกเว้นที่ผู้ใช้กำหนดโดยทั่วไปไม่มีการตรวจสอบข้อยกเว้นการตรวจสอบที่กำหนดเอง
3. กลไกการจัดการข้อยกเว้น
ในแอปพลิเคชัน Java กลไกการจัดการข้อยกเว้นคือ: โยนข้อยกเว้นและจับข้อยกเว้น
โยนข้อยกเว้น: เมื่อเกิดข้อผิดพลาดในวิธีการและยกข้อยกเว้นวิธีการสร้างวัตถุข้อยกเว้นและส่งไปยังระบบรันไทม์ วัตถุข้อยกเว้นมีข้อมูลข้อยกเว้นเช่นประเภทข้อยกเว้นและสถานะโปรแกรมเมื่อเกิดข้อยกเว้น ระบบรันไทม์มีหน้าที่รับผิดชอบในการค้นหาและเรียกใช้รหัสเพื่อจัดการข้อยกเว้น
ข้อยกเว้นสำหรับจับ: หลังจากวิธีการโยนข้อยกเว้นระบบรันไทม์จะหันไปมองหาตัวจัดการข้อยกเว้นที่เหมาะสม ตัวจัดการข้อยกเว้นที่เป็นไปได้คือการรวบรวมวิธีการที่ยังคงอยู่ในสแต็กการโทรเมื่อมีข้อยกเว้นเกิดขึ้น เมื่อประเภทข้อยกเว้นที่โปรเซสเซอร์ข้อยกเว้นสามารถจัดการได้สอดคล้องกับประเภทข้อยกเว้นที่โยนโดยวิธีการมันเป็นโปรเซสเซอร์ข้อยกเว้นที่เหมาะสม ระบบรันไทม์เริ่มต้นด้วยวิธีที่มีข้อยกเว้นเกิดขึ้นจากนั้นมองย้อนกลับไปที่วิธีการในสแต็กการโทรจนกว่าจะพบวิธีที่มีตัวจัดการข้อยกเว้นที่เหมาะสมและดำเนินการ เมื่อระบบรันไทม์เคลื่อนที่สแต็กการโทรและไม่พบตัวจัดการข้อยกเว้นที่เหมาะสมระบบรันไทม์จะสิ้นสุดลง ในขณะเดียวกันก็หมายถึงการยกเลิกโปรแกรม Java
สำหรับข้อยกเว้นรันไทม์ข้อผิดพลาดหรือข้อยกเว้นที่ตรวจพบได้วิธีการจัดการข้อยกเว้นที่ต้องการโดยเทคโนโลยี Java นั้นแตกต่างกัน
เนื่องจากข้อยกเว้นรันไทม์ที่ไม่สามารถตรวจจับได้เพื่อที่จะใช้แอปพลิเคชันที่สมเหตุสมผลและง่ายดาย Java กำหนดว่าข้อยกเว้นรันไทม์จะถูกโยนโดยระบบรันไทม์ Java โดยอัตโนมัติทำให้แอปพลิเคชันไม่สนใจข้อยกเว้นรันไทม์
สำหรับข้อผิดพลาดที่อาจเกิดขึ้นระหว่างการดำเนินการวิธีการ Java อนุญาตให้วิธีการไม่โยนการประกาศใด ๆ เมื่อวิธีการไม่ถูกจับ เนื่องจากข้อยกเว้นข้อผิดพลาดส่วนใหญ่เป็นสถานการณ์ที่ไม่สามารถเกิดขึ้นได้และยังเป็นข้อยกเว้นที่แอปพลิเคชันที่สมเหตุสมผลไม่ควรจับ
สำหรับข้อยกเว้นที่ตรวจสอบได้ทั้งหมด Java กำหนดว่าต้องจับวิธีการหรือประกาศนอกวิธีการโยน นั่นคือเมื่อวิธีการเลือกที่จะไม่จับข้อยกเว้นที่ตรวจสอบได้จะต้องประกาศว่าข้อยกเว้นจะถูกโยนทิ้ง
วิธีการที่สามารถจับข้อยกเว้นได้ต้องจัดหาตัวจัดการข้อยกเว้นประเภทที่สอดคล้องกัน ข้อยกเว้นที่จับได้อาจเกิดจากข้อยกเว้นที่ยกขึ้นและโยนโดยคำสั่งของตัวเองหรือข้อยกเว้นที่ถูกโยนโดยวิธีการที่เรียกว่าหรือระบบรันไทม์ Java ฯลฯ กล่าวอีกนัยหนึ่งข้อยกเว้นที่วิธีการจับต้องเป็นข้อยกเว้นที่ถูกโยนลงโดยรหัส Java ที่ไหนสักแห่ง พูดง่ายๆคือข้อยกเว้นจะถูกโยนทิ้งไว้ก่อนแล้วก็จับได้
รหัส Java ใด ๆ สามารถโยนข้อยกเว้นเช่น: รหัสที่เขียนด้วยตัวเองรหัสจากแพ็คเกจการพัฒนา Java หรือระบบรันไทม์ Java ไม่ว่าจะเป็นใครคุณสามารถโยนข้อยกเว้นผ่านคำสั่ง Java Throw
ข้อยกเว้นใด ๆ ที่โยนจากวิธีการจะต้องใช้กับประโยคการโยน
การจับข้อยกเว้นนั้นทำได้ผ่านคำสั่งลองจับหรือคำสั่งลองจับในรอบสุดท้าย
โดยทั่วไปแล้ว Java กำหนดว่าจะต้องมีข้อยกเว้นที่ตรวจสอบได้หรือประกาศโยน อนุญาตให้เพิกเฉยต่อ RuntimeException และข้อผิดพลาดที่ไม่ได้ตรวจสอบ
3.1 จับข้อยกเว้น: ลองจับและในที่สุด
1. คำสั่งจับ
ใน Java ข้อยกเว้นจะถูกจับโดยคำสั่งลองจับ รูปแบบไวยากรณ์ทั่วไปคือ:
ลอง {// รหัสโปรแกรมโดยที่ข้อยกเว้นอาจเกิดขึ้น} catch (type1 id1) {// catch และจัดการกับประเภทข้อยกเว้นที่โยนโดยลอง type1} catch (type2 id2) {// catch และจัดการกับประเภทข้อยกเว้นที่โยนโดยลอง Type2}คู่ของการจัดฟันหลังจากคำหลักลองห่อโค้ดที่อาจมีข้อยกเว้นซึ่งเรียกว่าพื้นที่การตรวจสอบ หากมีข้อยกเว้นเกิดขึ้นระหว่างวิธี Java ในระหว่างการทำงานวัตถุข้อยกเว้นจะถูกสร้างขึ้น โยนข้อยกเว้นนอกพื้นที่การตรวจสอบและระบบรันไทม์ Java พยายามค้นหาประโยคจับจับคู่เพื่อจับข้อยกเว้น หากมีประโยคจับคู่ที่ตรงกันให้เรียกใช้รหัสการจัดการข้อยกเว้นและคำสั่งลองจับจะสิ้นสุดลง
หลักการของการจับคู่คือ: หากวัตถุข้อยกเว้นที่ถูกโยนเป็นของคลาสข้อยกเว้นของประโยคการจับหรือเป็นของคลาสย่อยของคลาสข้อยกเว้นถือว่าถือว่าวัตถุข้อยกเว้นที่สร้างขึ้นตรงกับประเภทข้อยกเว้นที่จับโดยบล็อกจับ
ตัวอย่างที่ 1 จับ "ตัวแบ่งเป็น 0" ข้อยกเว้นที่ถูกโยนลงโดยคำสั่งโยน
Public Class Testexception {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int a = 6; int b = 0; ลอง {// ลองใช้พื้นที่ตรวจสอบถ้า (b == 0) โยน arithMeticexception ใหม่ (); // โยนข้อยกเว้นผ่านคำสั่ง throw system.out.println ("ค่าของ a/ b คือ:" + a/ b); } catch (arithmeticexception e) {// catch catch exception system.out.println ("โปรแกรมมีข้อยกเว้นและตัวแปร B ไม่สามารถเป็น 0"); } system.out.println ("โปรแกรมสิ้นสุดตามปกติ"); -ผลการทำงาน: โปรแกรมมีข้อยกเว้นและตัวแปร B ไม่สามารถเป็น 0
โปรแกรมสิ้นสุดตามปกติ
ตัวอย่างที่ 1 ในพื้นที่การตรวจสอบลองใช้คำสั่งเพื่อตัดสิน เมื่อเงื่อนไขข้อผิดพลาดของ "ตัวหารคือ 0" ถูกสร้างขึ้นจะมีการสร้างข้อยกเว้น arithmeticexception และคำสั่งการโยนส่งข้อยกเว้นไปยังระบบรันไทม์ Java ระบบค้นหาตัวจัดการข้อยกเว้นจับคู่และเรียกใช้รหัสการจัดการข้อยกเว้นที่สอดคล้องกัน พิมพ์ออกมา "โปรแกรมมีข้อยกเว้นและตัวแปร B ไม่สามารถเป็น 0" คำสั่งลองจับจะสิ้นสุดลงและดำเนินการโฟลว์ของโปรแกรมต่อไป
ในความเป็นจริง arithmeticexception เช่น "ตัวแบ่งคือ 0" เป็นคลาสย่อยของ runtimexception ข้อยกเว้นรันไทม์จะถูกโยนโดยระบบรันไทม์โดยอัตโนมัติและไม่จำเป็นต้องใช้คำสั่งโยน
ตัวอย่างที่ 2: จับข้อยกเว้น arithmeticexception ที่เกิดจาก "ตัวหารคือ 0" การขว้างโดยอัตโนมัติระหว่างระบบรันไทม์
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int a = 6; int b = 0; ลอง {system.out.println ("ค่าของ a / b คือ:" + a / b); } catch (arithmeticexception e) {system.out.println ("โปรแกรมมีข้อยกเว้นและตัวแปร B ไม่สามารถเป็น 0"); } system.out.println ("โปรแกรมสิ้นสุดตามปกติ"); -ผลการทำงาน: โปรแกรมมีข้อยกเว้นและตัวแปร B ไม่สามารถเป็น 0
โปรแกรมสิ้นสุดตามปกติ
คำสั่งในตัวอย่างที่ 2:
System.out.println ("ค่า A/B คือ:" + A/B);ข้อผิดพลาดของ "ตัวหารคือ 0" ถูกสร้างขึ้นในระหว่างการรันไทม์และมีการยกข้อยกเว้น arithmeticexception ระบบรันไทม์สร้างวัตถุข้อยกเว้นและโยนพื้นที่การตรวจสอบแทนที่จะจับคู่จับมือจับข้อยกเว้นที่เหมาะสมและเรียกใช้รหัสการจัดการข้อยกเว้นที่เกี่ยวข้อง
เนื่องจากค่าใช้จ่ายในการตรวจสอบข้อยกเว้นรันไทม์นั้นสูงกว่าประโยชน์ของการจับข้อยกเว้นจึงไม่สามารถตรวจพบข้อยกเว้นรันไทม์ได้ คอมไพเลอร์ Java อนุญาตให้เพิกเฉยต่อข้อยกเว้นรันไทม์และวิธีการไม่สามารถจับหรือประกาศการโยนข้อยกเว้นรันไทม์ได้
ตัวอย่างที่ 3: ไม่มีการจับหรือประกาศว่าข้อยกเว้นรันไทม์ถูกโยนลงไป
Public Class Testexception {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int a, b; a = 6; b = 0; // ค่าของตัวหาร B คือ 0 System.out.println (a / b); -ผลการทำงาน:
ข้อยกเว้นในเธรด "Main" java.lang.arithmeticexception: / โดยศูนย์
ที่ test.testexception.main (testexception.java:8)
ตัวอย่างที่ 4 โปรแกรมอาจมีข้อยกเว้นของตัวหาร 0 และข้อยกเว้นของอาร์เรย์ตัวห้อยอาร์เรย์นอกขอบเขต
Public Class Testexception {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int [] intarray = new int [3]; ลอง {สำหรับ (int i = 0; i <= intarray.length; i ++) {intarray [i] = i; System.out.println ("intarray [" + i + "] =" + intarray [i]); System.out.println ("intarray [" + i + "] โมดูล" + (i - 2) + "ค่า:" + intarray [i] % (i - 2)); }} catch (arrayIndExOfBoundSexception e) {system.out.println ("Intarray Array Subscript นอกขอบเขต");); } catch (arithmeticexception e) {system.out.println ("ข้อยกเว้นของตัวหาร 0. "); } system.out.println ("โปรแกรมสิ้นสุดตามปกติ"); -ผลการทำงาน:
intarray [0] = 0
intarray [0] โมดูล -2 ค่า: 0
Intarray [1] = 1
ค่าของ intarray [1] modulo-1: 0
Intarray [2] = 2
ข้อยกเว้นของตัวหาร 0.
โปรแกรมสิ้นสุดตามปกติ
ตัวอย่างที่ 5 โปรแกรมอาจมีข้อยกเว้นของตัวหาร 0 และข้อยกเว้นของการห้อยอาร์เรย์อาจเกิดขึ้นได้เช่นกัน ในระหว่างการทำงานของโปรแกรมประเภทข้อยกเว้น arithmeticexception จับคู่ก่อนดังนั้นคำสั่งจับคู่จะถูกดำเนินการ:
catch (arithmeticexception e) {system.out.println ("ข้อยกเว้นของตัวหาร 0. "); -ควรสังเกตว่าเมื่อจับจับการจับประเภทข้อยกเว้นที่ตรงกันมันจะป้อนรหัสการจัดการข้อยกเว้น เมื่อการประมวลผลเสร็จสิ้นก็หมายความว่าคำสั่งลองทั้งหมดจะสิ้นสุดลง ข้อจับอื่น ๆ ไม่ได้มีโอกาสจับคู่และจับประเภทข้อยกเว้นอีกต่อไป
Java อธิบายประเภทข้อยกเว้นผ่านคลาสข้อยกเว้นและลำดับชั้นของคลาสข้อยกเว้นแสดงในรูปที่ 1 สำหรับโปรแกรมยกเว้นที่มีข้อจับหลายข้อคุณควรพยายามใส่ประโยคจับที่จับคลาสข้อยกเว้นพื้นฐานก่อน มิฉะนั้นประโยคจับที่จับคลาสข้อยกเว้นพื้นฐานจะถูกบล็อก
คลาส Exception RuntimeException รวมถึงข้อยกเว้นทั่วไปต่างๆที่รันไทม์และคลาส arithmeticexception และคลาส ArrayIndExOfBoundSexception เป็นคลาสย่อยทั้งสอง ดังนั้นควรใช้ประโยคการจับของคลาสข้อยกเว้น RuntimeException ในตอนท้ายมิฉะนั้นอาจบล็อกการจัดการข้อยกเว้นที่ตามมาหรือทำให้เกิดข้อผิดพลาดในการรวบรวม
2. คำสั่งลอง-จับรอบสุดท้าย
คำสั่งลองจับสามารถรวมส่วนที่สามซึ่งเป็นประโยคในที่สุด มันบ่งบอกถึงสิ่งที่ควรดำเนินการโดยไม่คำนึงว่ามีข้อยกเว้นเกิดขึ้นหรือไม่ รูปแบบไวยากรณ์ทั่วไปของคำสั่งลอง-จับรอบสุดท้ายคือ:
ลอง {// รหัสโปรแกรมที่อาจเกิดขึ้นข้อยกเว้น} catch (type1 id1) {// catch และประมวลผลประเภทข้อยกเว้นที่โยนโดยลอง type1} catch (type2 id2) {// จับและประมวลผลประเภทข้อยกเว้นที่ถูกโยนโดยลอง Type2} ในที่สุด {// บล็อกของคำสั่งตัวอย่างที่ 6 ตัวจัดการข้อยกเว้นที่มีประโยคในที่สุด
Public Class Testexception {โมฆะคงที่สาธารณะหลัก (String args []) {int i = 0; String Greetings [] = {"Hello World!", "Hello World !!", "Hello World !!!" - ในขณะที่ (i <4) {ลอง {// ให้ความสนใจเป็นพิเศษกับการออกแบบตัวแปรควบคุมลูปฉันเพื่อหลีกเลี่ยงการก่อให้เกิดการวนซ้ำที่ไม่มีที่สิ้นสุด system.out.println (คำทักทาย [i ++]); } catch (arrayIndexoutofboundsexception e) {system.out.println ("arraysubscript ข้อยกเว้นนอกขอบเขต"); } ในที่สุด {system.out.println ("--------------------------"); -ผลการทำงาน:
สวัสดีโลก!
-
สวัสดีโลก !!
-
สวัสดีโลก !!!
-
อาร์เรย์ตัวห้อยอาร์เรย์ออกจากข้อยกเว้นขอบเขต
-
ในตัวอย่างที่ 6 โปรดให้ความสนใจเป็นพิเศษกับการออกแบบบล็อกคำสั่งในข้อลอง หากการออกแบบมีดังนี้ลูปที่ตายแล้วจะเกิดขึ้น หากออกแบบเป็น:
ลอง {system.out.println (คำทักทาย [i]); i ++; -สรุป:
ลองบล็อก: ใช้เพื่อจับข้อยกเว้น หลังจากนั้นก็สามารถเชื่อมต่อบล็อกจับได้เป็นศูนย์หรือมากกว่า หากไม่มีการจับบล็อกจะต้องตามด้วยบล็อกในที่สุด
Catch Block: ใช้เพื่อจัดการข้อยกเว้นที่จับได้โดยลอง
ในที่สุดบล็อก: ข้อความในบล็อกในที่สุดจะถูกดำเนินการโดยไม่คำนึงว่าข้อยกเว้นจะถูกจับหรือประมวลผล เมื่อพบคำสั่ง Return ในบล็อกลองหรือบล็อก catch บล็อกคำสั่งสุดท้ายจะ
ดำเนินการก่อนที่วิธีการจะส่งคืน ใน 4 กรณีพิเศษต่อไปนี้บล็อกในที่สุดจะไม่ถูกดำเนินการ:
1) ข้อยกเว้นเกิดขึ้นในบล็อกคำสั่งสุดท้าย
2) ใช้ System.Exit () ในรหัสก่อนหน้าเพื่อออกจากโปรแกรม
3) เธรดที่โปรแกรมตั้งอยู่
4) ปิด CPU
3. กฎการจับ-การจับในอันดับแรก (กฎไวยากรณ์สำหรับคำสั่งการจัดการข้อยกเว้น):
1) ต้องเพิ่มการจับหรือบล็อกในที่สุดหลังจากลอง หลังจากลองบล็อกการจับและบล็อกในที่สุดก็สามารถเชื่อมต่อได้ในเวลาเดียวกัน แต่มีอย่างน้อยหนึ่งบล็อก
2) จะต้องปฏิบัติตามลำดับบล็อก: หากรหัสใช้ทั้งการจับและบล็อกในที่สุดจะต้องวางบล็อกการจับหลังจากบล็อกลอง
3) การจับบล็อกเกี่ยวข้องกับประเภทของคลาสข้อยกเว้นที่สอดคล้องกัน
4) บล็อกลองอาจมีหลายบล็อกจับ ถ้าเป็นเช่นนั้นบล็อกการจับคู่แรกจะถูกดำเนินการ นั่นคือเครื่องเสมือน Java ตรงกับวัตถุข้อยกเว้นที่เกิดขึ้นจริงกับประเภทข้อยกเว้นที่ประกาศโดยแต่ละบล็อกรหัสจับตามลำดับ หากวัตถุข้อยกเว้นเป็นประเภทข้อยกเว้นหรืออินสแตนซ์ของ subclass บล็อก catch code จะถูกดำเนินการและจะไม่มีการเรียกใช้บล็อกรหัสจับอื่น ๆ
5) โครงสร้างการจับที่จับใจในรอบสุดท้าย
6) ในโครงสร้างการจับ-การจับรอบสุดท้ายสามารถถูกโยนอีกครั้ง
7) นอกเหนือจากสถานการณ์ต่อไปนี้การดำเนินการของการสิ้นสุดในที่สุด: JVM จะสิ้นสุดลงก่อนกำหนด (เรียกว่า System.Exit (int)); โยนข้อยกเว้นที่ไม่สามารถจัดการได้ในบล็อกสุดท้าย; คอมพิวเตอร์ถูกขับเคลื่อนออกมายิงหรือถูกโจมตีโดยไวรัส
4. ลำดับการดำเนินการของการลองจับและในที่สุดบล็อกคำสั่ง:
1) เมื่อการลองไม่ได้จับข้อยกเว้น: คำสั่งในบล็อกคำสั่งลองจะถูกดำเนินการทีละรายการและโปรแกรมจะข้ามบล็อกคำสั่ง Catch และเรียกใช้งานบล็อกคำสั่งสุดท้ายและคำสั่งที่ตามมา;
2) เมื่อลองจับข้อยกเว้นบล็อกคำสั่ง Catch ไม่ได้จัดการกับข้อยกเว้นนี้: เมื่อข้อยกเว้นเกิดขึ้นในคำสั่งในบล็อกคำสั่งลองและบล็อกคำสั่ง Catch ที่ไม่จัดการกับข้อยกเว้นนี้ข้อยกเว้นจะถูกส่งไปยัง JVM สำหรับการประมวลผลและคำสั่งในบล็อกคำสั่งสุดท้ายจะยังคงดำเนินการ
3) เมื่อลองจับข้อยกเว้นบล็อกคำสั่ง Catch จะจัดการกับข้อยกเว้นนี้: มันถูกดำเนินการในบล็อกคำสั่งลองตามลำดับ เมื่อข้อยกเว้นเกิดขึ้นเมื่อมีข้อยกเว้นเกิดขึ้นในคำสั่งโปรแกรมจะข้ามไปยังบล็อกคำสั่ง Catch และจับคู่ทีละรายการ ค้นหาตัวจัดการที่เกี่ยวข้อง บล็อกคำสั่งจับอื่น ๆ จะไม่ถูกดำเนินการ ในบล็อกคำสั่งลองคำสั่งหลังจากข้อยกเว้นจะไม่ถูกดำเนินการ หลังจากดำเนินการบล็อกคำสั่ง Catch แล้วคำสั่งในบล็อกคำสั่งสุดท้ายจะถูกดำเนินการและในที่สุดคำสั่งหลังจากบล็อกคำสั่งสุดท้ายจะถูกดำเนินการ;
ภาพประกอบของการดำเนินการของการลองจับและในที่สุดบล็อกคำสั่ง:
รูปที่ 2 แสดงให้เห็นถึงการดำเนินการของการลองจับและในที่สุดบล็อกคำสั่ง
3.2 โยนข้อยกเว้น
รหัส Java ใด ๆ สามารถโยนข้อยกเว้นเช่น: รหัสที่เขียนด้วยตัวเองรหัสจากแพ็คเกจการพัฒนา Java หรือระบบรันไทม์ Java ไม่ว่าจะเป็นใครคุณสามารถโยนข้อยกเว้นผ่านคำสั่ง Java Throw ข้อยกเว้นใด ๆ ที่โยนจากวิธีการจะต้องใช้กับประโยคการโยน
1. โยนข้อยกเว้น
หากวิธีการอาจมีข้อยกเว้น แต่ไม่มีความสามารถในการจัดการข้อยกเว้นดังกล่าวคุณสามารถใช้ประโยคการโยนเพื่อประกาศข้อยกเว้นที่ถูกโยนลงในการประกาศวิธีการ ตัวอย่างเช่นรถอาจล้มเหลวเมื่อทำงานและรถเองไม่สามารถจัดการกับความล้มเหลวนี้ได้ดังนั้นให้คนขับจัดการกับมัน
คำสั่ง THROWS ใช้เพื่อประกาศประเภทของข้อยกเว้นที่จะโยนเมื่อมีการกำหนดวิธีการ หากมีการโยนประเภทข้อยกเว้นข้อยกเว้นวิธีการจะถูกประกาศให้โยนข้อยกเว้นทั้งหมด ข้อยกเว้นหลายข้อสามารถแยกได้โดยใช้เครื่องหมายจุลภาค รูปแบบไวยากรณ์ของคำสั่งโยนคือ:
MethodName พ่นข้อยกเว้น 1, Exception2, .. , ExceptionN {} โยนหลังจากชื่อวิธีการยกเว้น 1, Exception2, ... , ExceptionN เป็นรายการของข้อยกเว้นที่จะโยน เมื่อวิธีการส่งรายการข้อยกเว้นวิธีการจะไม่จัดการข้อยกเว้นของประเภทเหล่านี้และประเภท subclass ของพวกเขา แต่จะถูกโยนลงไปในวิธีที่เรียกวิธีการและจะได้รับการจัดการ ตัวอย่างเช่น:
นำเข้า java.lang.exception; Public Class Testexception {โมฆะคงที่ป๊อป () พ่น negativeArraysizeException {// กำหนดวิธีการและโยน negativeArraySeException Exception int [] arr = new int [-3]; // สร้างอาร์เรย์} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// วิธีหลักลอง {// ลองใช้คำสั่งจัดการข้อมูลข้อยกเว้นป๊อป (); // เรียกเมธอดป๊อป ()} catch (negativeArraysizeException e) {system.out.println ("ข้อยกเว้นที่ถูกโยนโดยเมธอด POP ()"); // ข้อมูลข้อยกเว้นเอาต์พุต}}}หลังจากโยนข้อยกเว้นไปยังผู้โทรโดยใช้คำหลักพุ่มหากผู้โทรไม่ต้องการจัดการข้อยกเว้นคุณสามารถโยนมันต่อไปได้ แต่ในที่สุดก็ต้องมีผู้โทรที่สามารถจัดการข้อยกเว้นได้
วิธีการป๊อปไม่ได้จัดการกับข้อยกเว้น negativearraysizeException แต่ได้รับการจัดการโดยฟังก์ชั่นหลัก
กฎสำหรับการขว้างเพื่อโยนข้อยกเว้น:
1) หากเป็นข้อยกเว้นที่ไม่ได้ตรวจสอบนั่นคือข้อผิดพลาด, runtimeException หรือ subclasses ของพวกเขาคุณสามารถประกาศข้อยกเว้นที่จะโยนโดยไม่ต้องใช้คำหลักโยนและการรวบรวมจะยังคงผ่านไปอย่างราบรื่น แต่มันจะถูกโยนโดยระบบที่รันไทม์
2) ต้องมีการประกาศข้อยกเว้นใด ๆ ที่สามารถโยนได้โดยวิธีการ นั่นคือถ้าวิธีการอาจมีข้อยกเว้นที่ตรวจสอบได้มันจะถูกจับด้วยคำสั่งลองจับหรือโยนมันด้วยการประกาศประโยคการโยนมิฉะนั้นจะทำให้เกิดข้อผิดพลาดในการรวบรวม
3) เฉพาะเมื่อมีการโยนข้อยกเว้นผู้โทรของวิธีการจะต้องจัดการหรือโยนข้อยกเว้นอีกครั้ง เมื่อผู้เรียกวิธีการไม่สามารถจัดการกับข้อยกเว้นได้ควรโยนมันต่อไปแทนที่จะกลืนมันทั้งหมด
4) วิธีการโทรจะต้องปฏิบัติตามกฎการจัดการข้อยกเว้นและการประกาศใด ๆ หากวิธีการถูกเขียนทับจะไม่สามารถประกาศข้อยกเว้นที่แตกต่างจากวิธีที่เขียนทับได้ ข้อยกเว้นใด ๆ ที่ประกาศจะต้องเป็นคลาสที่คล้ายกันหรือ subclass ของข้อยกเว้นที่ประกาศโดยวิธีการแทนที่
ตัวอย่างเช่น:
โมฆะวิธีการ 1 () พ่น IOException {} // legal // ข้อผิดพลาดการรวบรวม, iOexception ต้องถูกจับหรือประกาศให้โยนโมฆะวิธีการ 2 () {method1 (); } // ถูกกฎหมายประกาศให้โยน iOException โมฆะวิธีการ 3 () พ่น IOException {method1 (); } // ถูกกฎหมายประกาศให้โยนข้อยกเว้น iOexception เป็นคลาสย่อยของวิธีการยกเว้นวิธีการโมฆะ () โยนข้อยกเว้น {method1 (); } // ถูกกฎหมาย, การจับภาพ IOException Void Method5 () {ลอง {method1 (); } catch (ioexception e) {…}} // ข้อผิดพลาดการรวบรวมคุณต้องจับหรือประกาศวิธีการที่เป็นโมฆะข้อยกเว้นที่โยน 6 () {ลอง {method1 (); } catch (ioexception e) {โยนข้อยกเว้นใหม่ ();}} // ถูกกฎหมายประกาศการโยนโมฆะข้อยกเว้นวิธี 7 () โยนข้อยกเว้น {ลอง {method1 (); } catch (ioexception e) {โยนข้อยกเว้นใหม่ ();}} พื้นฐานสำหรับการพิจารณาว่าข้อยกเว้นอาจเกิดขึ้นในวิธีการดังนี้:
1) มีคำสั่งโยนในวิธีการ ตัวอย่างเช่นบล็อก Catch Code ของวิธีการข้างต้น 7 () มีคำสั่งการโยน
2) วิธีการอื่น ๆ ถูกเรียกและวิธีการอื่น ๆ ใช้ประโยคโยนเพื่อประกาศข้อยกเว้นบางอย่างที่จะโยน ตัวอย่างเช่นวิธีการ Method3 () เรียกใช้เมธอด 1 () วิธีการและวิธีการที่ 1 () ประกาศว่าการโยน iOException ถูกโยนลงดังนั้น iOException อาจเกิดขึ้นในวิธี Method3 ()
2. ใช้การโยนเพื่อโยนข้อยกเว้น
การโยนจะปรากฏขึ้นเสมอในร่างกายฟังก์ชั่นและใช้เพื่อโยนข้อยกเว้นของประเภทที่โยนได้ โปรแกรมจะยุติทันทีหลังจากคำสั่งการโยนคำสั่งหลังจากไม่สามารถดำเนินการได้และในบล็อกลองทั้งหมดที่มี (อาจจะอยู่ในฟังก์ชั่นการโทรระดับบน) มองหาบล็อกลองที่มีประโยคจับที่ตรงกับมันจากด้านใน
เรารู้ว่าข้อยกเว้นเป็นวัตถุอินสแตนซ์ของคลาสข้อยกเว้นและเราสามารถสร้างวัตถุอินสแตนซ์ของคลาสข้อยกเว้นที่จะถูกโยนผ่านคำสั่งการโยน รูปแบบไวยากรณ์ของคำสั่งนี้คือ:
โยนชื่อข้อยกเว้นใหม่;
ตัวอย่างเช่นโยนวัตถุข้อยกเว้นของคลาส IOException:
โยน iOexception ใหม่;
ควรสังเกตว่าพ่นวัตถุอินสแตนซ์เฉพาะที่สามารถโยนคลาสที่โยนได้หรือ subclasses การดำเนินการต่อไปนี้ไม่ถูกต้อง:
โยนสตริงใหม่ ("ข้อยกเว้น");นี่เป็นเพราะสตริงไม่ใช่คลาสย่อยของคลาสที่สามารถโยนได้
หากมีการโยนข้อยกเว้นการตรวจสอบคุณควรประกาศประเภทของข้อยกเว้นที่วิธีการอาจโยนลงในส่วนหัวของเมธอด ผู้โทรของวิธีนี้จะต้องตรวจสอบการจัดการข้อยกเว้นที่ถูกโยนทิ้ง
หากวิธีการทั้งหมดโยนเลเยอร์ข้อยกเว้นที่ได้มาโดยเลเยอร์ JVM จะประมวลผลในที่สุดและการประมวลผลก็ง่ายมากซึ่งก็คือการพิมพ์ข้อความข้อยกเว้นและข้อมูลสแต็ก หากมีข้อผิดพลาดหรือ RuntimeException ถูกโยนลงผู้โทรของวิธีการมีตัวเลือกในการจัดการข้อยกเว้น
การทดสอบแพ็คเกจ; นำเข้า java.lang.exception; Public Class Testexception {ความฉลาดทาง int แบบคงที่ (int x, int y) พ่น myexception {// define วิธีการโยนข้อยกเว้นถ้า (y <0) {// กำหนดว่าพารามิเตอร์น้อยกว่า 0 โยน myexception ใหม่ ("ตัวหารไม่สามารถเป็นจำนวนลบ"); // ข้อมูลข้อยกเว้น} ส่งคืน x/y; // ค่าส่งคืน} โมฆะคงที่สาธารณะหลัก (สตริง args []) {// วิธีการหลัก int a = 3; int b = 0; ลอง {// คำสั่งลองมีคำสั่งที่อาจมีข้อยกเว้น int result = quotient (a, b); // วิธีการโทร QUOTEENT ()} catch (myException e) {// จัดการระบบยกเว้นแบบกำหนดเอง. OUT.println (E.getMessage ()); // ข้อมูลข้อยกเว้นเอาท์พุท} catch (arithMeticexception e) {// จัดการ arithMeticexception system.out.out.println ("การหย่าร้างไม่สามารถเป็น 0"); // ข้อมูลพรอมต์เอาต์พุต} catch (Exception e) {// จัดการข้อยกเว้นอื่น ๆ System.out.println ("ข้อยกเว้นอื่น ๆ เกิดขึ้นในโปรแกรม"); // ข้อมูลพรอมต์เอาท์พุท}}} คลาส MyException ขยายข้อยกเว้น {// สร้างข้อความสตริงคลาสยกเว้นแบบกำหนดเอง; // กำหนดประเภทสตริงตัวแปร myexception สาธารณะ (String errorMessAgr) {// เมธอดเมธอดคลาสแม่แม่ = errorMessagr; } Public String getMessage () {// แทนที่เมธอด getMessage () ข้อความวิธีการส่งคืน; -3.3 โซ่ยกเว้น
1) หากมีการเรียกความฉลาด (3, -1) ข้อยกเว้น MyException จะเกิดขึ้นและโปรแกรมจะถูกถ่ายโอนไปยังบล็อก Catch (MyException E) เพื่อดำเนินการ;
2) หากมีการเรียกความฉลาด (5,0) จะมีการเรียกใช้ข้อยกเว้น arithmeticexception เนื่องจากข้อผิดพลาด "Divider คือ 0" มันเป็นของคลาส Runtime Exception และถูกโยนโดยระบบ Java Runtime โดยอัตโนมัติ วิธีการวัด () ไม่ได้จับข้อยกเว้น arithmeticexception ระบบรันไทม์ Java จะค้นหาวิธีการหลักตามวิธีการเรียกใช้สแต็กและอัปโหลดข้อยกเว้นที่ถูกโยนไปยังผู้โทรของวิธี quotient ():
int result = ความฉลาด (a, b); // วิธีการโทรหาวิธีการ ()
เนื่องจากคำสั่งนี้อยู่ในพื้นที่การตรวจสอบการลองใช้ arithmeticexception กับ "Divider คือ 0" ที่ผ่านมาถูกโยนโดยระบบรันไทม์ Java และตรงกับประโยคจับ:
catch (arithmeticexception e) {// จัดการ arithmeticexception system.out.println ("ตัวหารไม่สามารถเป็น 0"); // ข้อมูลพรอมต์เอาท์พุท}ผลการประมวลผลคือเอาต์พุต "ตัวแบ่งไม่สามารถเป็น 0" Java ซึ่งเป็นกลไกการประมวลผลที่ส่งผ่านข้อมูลข้อยกเว้นขึ้นรูปเป็นห่วงโซ่ข้อยกเว้น
ข้อยกเว้นที่สามารถตรวจสอบได้โดยวิธี Java จะถูกส่งผ่านไปยังวิธีการโทรด้วยความสามารถในการประมวลผลตามสแต็กการโทรและตามลำดับชั้นของวิธีการโทรและระดับสูงสุดจะเป็นจนถึงวิธีหลัก หากข้อยกเว้นถูกส่งผ่านไปยังวิธีการหลัก แต่หลักไม่มีความสามารถในการจัดการและไม่โยนข้อยกเว้นผ่านการประกาศการโยนอาจเกิดข้อผิดพลาดในการรวบรวม
3) หากมีข้อยกเว้นอื่น ๆ เกิดขึ้นจับ (ข้อยกเว้น e) จะถูกใช้เพื่อจับ 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抛出异常”例子已经提到了。
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น