ตัวอย่างในบทความนี้อธิบายการใช้งานการจัดการข้อยกเว้นของ Java แบ่งปันกับทุกคนสำหรับการอ้างอิงของคุณ การวิเคราะห์เฉพาะมีดังนี้:
กลไกการจัดการข้อยกเว้นของ Java สามารถช่วยให้เราหลีกเลี่ยงหรือจัดการกับข้อผิดพลาดที่อาจเกิดขึ้นในโปรแกรมเพื่อให้โปรแกรมไม่ยุติโดยไม่คาดคิดเมื่อพบข้อผิดพลาดที่สามารถกู้คืนได้ แต่เพื่อจัดการกับข้อผิดพลาดเหล่านี้ซึ่งทำให้เราเขียนโปรแกรมได้ดีขึ้น ไม่มีเลย จำเป็นต้องเขียนโค้ดจำนวนมากเพื่อตรวจสอบเงื่อนไขข้อผิดพลาด ซึ่งช่วยเพิ่มความสามารถในการอ่านและตรรกะของโค้ด ใน Java ข้อยกเว้นแสดงถึงวัตถุเอนทิตีที่ไม่ถูกต้อง
ข้อยกเว้นสามารถแบ่งออกเป็นสองประเภท ประเภทแรกคือข้อผิดพลาดร้ายแรง เช่น ข้อผิดพลาดของฮาร์ดแวร์ หน่วยความจำไม่เพียงพอ ฯลฯ ซึ่งสอดคล้องกับคลาส Error และคลาสย่อยภายใต้แพ็คเกจ java.lang โดยปกติโปรแกรมข้อผิดพลาดประเภทนี้จะไม่สามารถกู้คืนได้ และจำเป็นต้องขัดจังหวะการทำงานของโปรแกรม อีกประเภทหนึ่งคือข้อผิดพลาดที่ไม่ร้ายแรง เช่น ผู้ใช้ป้อนข้อมูลที่ผิดกฎหมาย หารด้วย 0 เป็นต้น ซึ่งสอดคล้องกับคลาสข้อยกเว้นและ ข้อยกเว้นในแพ็คเกจ java.lang โดยทั่วไปข้อผิดพลาดประเภทนี้สามารถกู้คืนได้โดยไม่กระทบต่อการทำงานของโปรแกรม
เราสามารถใช้คำสำคัญ try, catch และสุดท้ายเพื่อตรวจจับข้อยกเว้น
1. พยายามจับ
ใส่คำสั่งที่อาจทำให้เกิดข้อยกเว้นในบล็อก try{} จากนั้นจับคำสั่งเหล่านั้นในบล็อกคำสั่ง catch{} ข้อยกเว้นหากหารด้วย 0:
SimpleDemo คลาสสาธารณะ { // การดำเนินการกอง public static int devision (int a, int b) { return a / b; } public static void main (String [] args) { ลอง { //5 หารด้วย 0 SimpleDemo.devision (5 ,0); System.out.println("ข้อยกเว้น"); } catch (e.printStackTrace(); } System.out.println("Finish" } }ผลการดำเนินการ:
อย่างที่คุณเห็น Finish จะถูกพิมพ์ออกมา ซึ่งบ่งชี้ว่าโปรแกรมไม่ได้หยุดทำงานเนื่องจากข้อผิดพลาดในการหารด้วย 0
ในเวลาเดียวกัน เรายังพบว่าคำสั่ง System.out.println ภายใต้ SimpleDemo.devision() ซึ่งไม่มีการดำเนินการข้อยกเว้นเกิดขึ้น เมื่อมีข้อยกเว้นเกิดขึ้น โปรแกรมจะกระโดดออกจากตำแหน่งการดำเนินการปัจจุบันโดยไม่ต้องดำเนินการคำสั่งตามข้อยกเว้น
2. ในที่สุด
คำสั่งในบล็อกสุดท้ายจะถูกดำเนินการโดยไม่คำนึงถึงว่ามีข้อยกเว้นเกิดขึ้นหรือไม่
บางคนอาจถาม เนื่องจากคำสั่งในบล็อกสุดท้ายจะถูกดำเนินการโดยไม่คำนึงว่าจะมีข้อยกเว้นเกิดขึ้นหรือไม่ แล้วในที่สุดสิ่งนี้จะส่งผลในทางปฏิบัติอย่างไร? ฉันไม่สามารถเขียนมันโดยตรงภายนอกโดยไม่ต้องในที่สุด?
ดังตัวอย่างข้างต้น เราเพิ่มการส่งคืนไปยังบล็อกคำสั่ง catch:
SimpleDemo คลาสสาธารณะ { // การดำเนินการกอง การแบ่ง int สาธารณะคงที่ (int a, int b) { กลับ a / b; } โมฆะสาธารณะหลัก (สตริง [] args) { ลอง { //5 หารด้วย 0 SimpleDemo.division (5 ,0); System.out.println("Exception"); } catch (ข้อยกเว้น e) { e.printStackTrace(); return; System.out.println("ในที่สุด"); } System.out.println("เสร็จสิ้น");ในขณะนี้ ยังไม่ได้พิมพ์ Finish ด้านนอกบล็อกสุดท้าย แต่จะพิมพ์ Final ด้านในบล็อกสุดท้าย
ในที่สุดก็มีประโยชน์มากในการพัฒนาจริง ตัวอย่างเช่น หากเราเปิดฐานข้อมูลและมีข้อยกเว้นเกิดขึ้นเมื่ออ่านและเขียนข้อมูลในฐานข้อมูล เราควรปิดการเชื่อมต่อฐานข้อมูลและปล่อยทรัพยากรที่เกี่ยวข้อง ในเวลานี้ เหมาะสมที่สุดที่จะเขียนโค้ดเพื่อปล่อยทรัพยากรในบล็อกสุดท้าย
แต่ควรสังเกตว่าบล็อกสุดท้ายจะไม่ถูกดำเนินการในกรณีเดียว หากโปรแกรมออกก่อนดำเนินการบล็อกสุดท้าย เช่น การเรียกใช้เมธอด System.exit() บล็อกสุดท้ายจะไม่มีโอกาสดำเนินการ
3. โยนข้อยกเว้น
หากมีข้อยกเว้นเกิดขึ้นในเมธอด แต่เราไม่ต้องการจัดการข้อยกเว้นโดยตรงในเมธอด แต่ต้องการให้ผู้เรียกเมธอดจัดการมัน เราสามารถใช้คีย์เวิร์ด Throws เพื่อประกาศวิธีการนี้เพื่อส่งข้อยกเว้น นี่เป็นเรื่องธรรมดามากในฟังก์ชัน API ของ Sun ตัวอย่างเช่น วิธีการอ่านใน java.io.Reader ได้รับการประกาศให้ส่ง IOException:
int สาธารณะอ่าน (ถ่าน [] cbuf) พ่น IOException
ในเวลานี้ เมื่อเราเรียกใช้เมธอด read เราต้องใส่มันไว้ในบล็อกคำสั่ง try เพื่อตรวจจับข้อยกเว้น มิฉะนั้นคอมไพลเลอร์จะรายงานข้อผิดพลาดและบังคับให้เราตรวจจับข้อยกเว้น
แน่นอน ถ้าเราไม่ต้องการจัดการข้อยกเว้นเมื่อเรียก read เราก็สามารถประกาศวิธีการที่เรียกเมธอด read ว่าเป็น Throw IOException เพื่อให้ข้อยกเว้นถูกส่งอีกครั้ง หากเราประกาศข้อยกเว้นในฟังก์ชันหลัก ข้อมูลข้อยกเว้นจะถูกบันทึกและประมวลผลโดย JVM ในที่สุด และผลการประมวลผลของ JVM คือการพิมพ์ข้อมูลข้อยกเว้นออกมาแล้วจึงยุติโปรแกรม
4. โครงสร้างการจัดการข้อยกเว้น
คลาสข้อยกเว้นทั้งหมดได้มาจากคลาสข้อยกเว้น ซึ่งหมายความว่าหากเราไม่แน่ใจว่าจะมีข้อยกเว้นประเภทใดเกิดขึ้น เราสามารถประกาศอ็อบเจ็กต์ Exception ได้โดยตรงเพื่อจับข้อยกเว้นทั้งหมดของคลาส Exception และคลาสย่อยของมัน แต่ให้ใส่ใจกับลำดับที่เขียนการจับ หากมี catches หลายครั้งหลังจากการลองและ catch แรกประกาศวัตถุ Exception จากนั้นข้อยกเว้นจะถูกจัดการโดยตรงโดย catch แรก และ catches ที่ตามมาจะไม่สามารถตรวจจับข้อยกเว้นนี้ได้ ข้อผิดพลาดประเภทนี้จะทำให้เกิดข้อผิดพลาดระหว่างการคอมไพล์ ตัวอย่างเช่น:
CatchDemo คลาสสาธารณะ { // การดำเนินการส่วน public static int department (int a, int b) { return a / b; } public static void main (String [] args) { ลอง { CatchDemo.division (4,0 } ) (ข้อยกเว้น e) { System.out.println ("คลาสข้อยกเว้น"); } catch (ArithmeticException e) { System.out.println ("คลาส ArithmeticException"); -คอมไพเลอร์แสดงผลว่า ArithmeticException ถูกจับได้ ซึ่งหมายความว่าข้อยกเว้นข้างต้นตรวจพบข้อยกเว้นนี้แล้ว และไม่จำเป็นต้องจับอีกครั้ง
จะเกิดอะไรขึ้นถ้าการจับทั้งสองนี้กลับกัน?
CatchDemo คลาสสาธารณะ { // การดำเนินการส่วน public static int department (int a, int b) { return a / b; } public static void main (String [] args) { ลอง { CatchDemo.division (4,0 } ) (ArithmeticException e) { System.out.println ("คลาส ArithmeticException"); } catch (ข้อยกเว้น e) { System.out.println ("คลาสข้อยกเว้น"); -ในเวลานี้ เราพบว่าโค้ดผ่านการคอมไพล์ และผลการดำเนินการคือ ArithmeticException ตรวจพบข้อยกเว้นนี้ แต่การจับที่ตามมากลับตรวจไม่พบ
ฉันหวังว่าบทความนี้จะเป็นประโยชน์กับการเขียนโปรแกรม Java ของทุกคน