ความเข้าใจที่ครอบคลุมเกี่ยวกับกลไกการจัดการข้อยกเว้นในชวา

1. สรุปข้อยกเว้น Java:

ข้อยกเว้นหมายถึงการทำงานที่ผิดปกติเมื่อโปรแกรมกำลังทำงานอยู่

1. ต้นกำเนิดของข้อยกเว้น:

คำอธิบายของปัญหาในเรื่องจริงผ่านรูปแบบของคลาส Java และปิดผนึกลงในวัตถุ

ในความเป็นจริงมันเป็นการรวมตัวกันของวัตถุหลังจาก Java อธิบายสถานการณ์ที่ผิดปกติ

2. มีปัญหาสองประเภท: หนึ่งคือปัญหาร้ายแรงและอีกปัญหาหนึ่งเป็นปัญหาร้ายแรง

สำหรับกรณีที่ร้ายแรง Java อธิบายผ่านคลาสข้อผิดพลาด

ข้อผิดพลาดโดยทั่วไปจะไม่ถูกเขียนขึ้นเพื่อประมวลผล

สำหรับไม่จริงจัง Java อธิบายโดยคลาสข้อยกเว้น

สำหรับข้อยกเว้นคุณสามารถใช้วิธีการประมวลผลเป้าหมายเพื่อจัดการได้

3. ข้อยกเว้นทั่วไปรวมถึง: ข้อยกเว้นมุมมองข้ามอาร์เรย์ข้อยกเว้นข้ามพรมแดนข้อยกเว้นตัวชี้ว่าง ...

4. ข้อผิดพลาดหรือข้อยกเว้นมีเนื้อหาทั่วไป

ตัวอย่างเช่น: ข่าวผิดปกติสาเหตุ ฯลฯ

ระดับพรีเมี่ยมแบบ throwable (สองคลาสต่อไปนี้ถูกสกัดจากสามัญชนเดียวกัน)

|-error

|-Excption // สองคลาสย่อย (มีปัญหามากมายที่กำหนด (เกิดข้อยกเว้น)) /*ชื่อคลาสพาเรนต์คือชื่อคำต่อท้ายคลาสย่อย* / /

ตัวอย่างที่ 1: ตัวอย่างของการเกิดข้อยกเว้น

 การสาธิตคลาส {public int div (int x, int y) {return x/y; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); int x = d.div (4,0); // 0 เป็นตัวหาร System.out.println ("x ="+x); System.out.println ("over"); -

ผลการทำงาน:

ข้อยกเว้นในเธรด "Main" java.lang.arithmeticexception: / โดยศูนย์

ที่ demo.div (ExceptionDemo.java:5)

ที่ ExceptionDemo.Main (ExceptionDemo.java:15)

จากผลลัพธ์ข้างต้นเราสามารถวิเคราะห์ว่ามีข้อยกเว้นที่เกิดขึ้นในทั้งสองบรรทัด 5 และ 15 นี่เป็นเพราะกลไกการแบ่งตัวหารไม่สามารถเป็น 0 และข้อยกเว้นจะถูกโยนลงเมื่อดำเนินการ

ตัวอย่างที่ 2: ข้อยกเว้นตัวอย่างที่ 2 หน่วยความจำล้น

 การสาธิตคลาส {public int div (int x, int y) {return x/y; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) { /*demo d = demo ใหม่ (); int x = d.div (4,0); System.out.println ("x ="+x); System.out.println ("over"); */ byte [] arr = byte ใหม่ [1024*1024*1000]; -

ผลการทำงาน:

ข้อยกเว้นในเธรด "Main" java.lang.outofMemoryError: พื้นที่ java heap
ที่ ExceptionDemo.Main (ExceptionDemo.java:19)

java.lang.outofMemoryError: แสดงถึงความทรงจำยกเว้น

2. การจัดการข้อยกเว้น:

สำหรับการจัดการข้อยกเว้น Java มีข้อความที่ไม่ซ้ำกันสำหรับการประมวลผล

รูปแบบ

พยายาม

-

รหัสที่ต้องตรวจพบ

-

จับ

-

รหัสสำหรับการจัดการข้อยกเว้น; (วิธีการประมวลผล)

-

ในที่สุด

-

รหัสที่จะดำเนินการอย่างแน่นอน (วิธีการประมวลผล)

-

ตัวอย่างที่ 1: แสดงคำสั่งลองจับ

 การสาธิตคลาส {public int div (int x, int y) {return x/y; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); ลอง {int x = d.div (4,0); System.out.println ("x ="+x); } catch (exception e) {system.out.println ("ตัวหารที่หย่าร้าง"); } system.out.println ("over"); /*byte [] arr = byte ใหม่ [1024*1024*1000];*/}}

ผลการทำงาน:

มีข้อผิดพลาดในตัวหาร

เกิน

การวิเคราะห์ผลลัพธ์: เมื่อโปรแกรมกำลังทำงานเมื่อมีการดำเนินการคำสั่งส่วน: return x/y วัตถุข้อยกเว้นจะถูกสร้างขึ้น archmeticexception ใหม่ () คำสั่งลองจับวัตถุนี้ด้วยพารามิเตอร์ของคำสั่ง Catch

ข้อยกเว้น e = archmeticexception ใหม่ ();

หลังจากเรียกใช้คำสั่ง Catch Processing แล้วปัญหาจะถูกประมวลผลแล้วคำสั่งสิ้นสุดจะเสร็จสิ้นแล้วและเอาต์พุตสิ้นสุดลง

ตัวอย่างที่ 2: ดำเนินการวิธีการทั่วไปในวัตถุข้อยกเว้นที่จับได้ (วิธีการที่คลาสแม่แบบโยนได้)

สตริง getMessage (); // รับข้อมูลข้อยกเว้น

ToString () // ส่งคืนชื่อข้อยกเว้น: ข้อมูลข้อยกเว้น

PrintStackTrace () // ชื่อข้อยกเว้นเอาต์พุตข้อมูลข้อยกเว้นตำแหน่งของการเกิดข้อยกเว้น

 การสาธิตคลาส {public int div (int x, int y) {return x/y; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); ลอง {int x = d.div (4,0); System.out.println ("x ="+x); } catch (exception e) {system.out.println ("ตัวหารที่หย่าร้าง"); // รับ Sempant Information System.out.println (E.getMessage ()); // รับข้อมูลข้อยกเว้น, ชื่อข้อยกเว้น System.out.println (e.toString ()); // ชื่อข้อยกเว้นเอาต์พุตข้อมูลข้อยกเว้นตำแหน่งที่มีข้อยกเว้นเกิดขึ้น e.printstacktrace (); } system.out.println ("over"); /*byte [] arr = byte ใหม่ [1024*1024*1000];*/}}

ผลการทำงาน:

มีข้อผิดพลาดในตัวหาร

/ โดยศูนย์
java.lang.arithmeticexception: / By Zero
java.lang.arithmeticexception: / By Zero

ที่ demo.div (ExceptionDemo.java:5)

ที่ ExceptionDemo.Main (ExceptionDemo.java:17)

เกิน

จากการวิเคราะห์ผลการทำงานกลไกการจัดการข้อยกเว้นเริ่มต้นของ JVM จริง ๆ แล้วเรียกใช้วิธี PrintStackTrace

ตัวอย่างที่ 3: สองวิธีในการจัดการการขว้างข้อยกเว้น

1. โยนมันไปที่เครื่องเสมือน JVM สำหรับการประมวลผล

2. จัดการข้อยกเว้นที่โยนด้วยตัวเอง

 การสาธิตคลาส {public int div (int x, int y) โยนข้อยกเว้น/*ข้อยกเว้นโยนเมื่อข้อยกเว้นอาจเกิดขึ้น*/{return x/y; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); int x = d.div (4,0); System.out.println ("x ="+x); System.out.println ("over"); -

ผลการทำงาน:

ExceptionDemo.java:15: ข้อผิดพลาด: ข้อผิดพลาดข้อยกเว้นข้อยกเว้นที่ไม่ได้รายงาน; จะต้องถูกจับหรือประกาศให้ขว้างปา
int x = d.div (4,0);
-

1 ข้อผิดพลาด

การวิเคราะห์ผลลัพธ์: นี่เป็นเพราะไม่มีการประมวลผลข้อยกเว้น

วิธีการประมวลผล 1: โยนข้อยกเว้นอย่างต่อเนื่องและปล่อยให้เครื่องเสมือน JVM จัดการกับมันเอง

 การสาธิตคลาส {public int div (int x, int y) โยนข้อยกเว้น/*ข้อยกเว้นโยนเมื่อข้อยกเว้นอาจเกิดขึ้น*/{return x/y; }} class ExceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) โยนข้อยกเว้น /*ต่อไปเพื่อโยนข้อยกเว้นและมอบให้กับเครื่องเสมือน* / {demo d = การสาธิตใหม่ (); int x = d.div (4,0); System.out.println ("x ="+x); System.out.println ("over"); -

วิธีการจัดการที่ 2: จัดการข้อยกเว้นด้วยตัวเอง

 การสาธิตคลาส {public int div (int x, int y) โยนข้อยกเว้น/*ข้อยกเว้นโยนเมื่อข้อยกเว้นอาจเกิดขึ้น*/{return x/y; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); ลอง // จัดการข้อยกเว้นด้วยตัวเอง {int x = d.div (4,0); System.out.println ("x ="+x); } catch (exception e) {system.out.println ("ตัวหารที่หย่าร้าง"); // รับข้อมูลข้อยกเว้น, ชื่อข้อยกเว้น System.out.println (e.toString ()); System.out.println ("over"); -

สรุป:

ประกาศข้อยกเว้นเกี่ยวกับฟังก์ชั่น มันสะดวกในการปรับปรุงความปลอดภัยช่วยให้แหล่งโทรสามารถดำเนินการได้โดยไม่ต้องประมวลผลความล้มเหลวในการรวบรวม

ตัวอย่างที่ 4: จัดการข้อยกเว้นหลายข้อ

1. เมื่อประกาศข้อยกเว้นขอแนะนำให้ประกาศข้อยกเว้นเฉพาะเพิ่มเติมเพื่อให้สามารถจัดการได้โดยเฉพาะ

2. ประกาศข้อยกเว้นหลายประการและมีหลายบล็อกจับ อย่ากำหนดจับที่ไม่จำเป็นอย่างรวดเร็ว

หากมีความสัมพันธ์ในการสืบทอดในหลายบล็อกการจับบล็อกข้อยกเว้นคลาสแม่จะถูกวางไว้ด้านล่าง

 การสาธิตคลาส {public int div (int x, int y) พ่น arithmeticexception, arrayIndexoutofboundsexception {int arr [] = new int [x]; System.out.println (arr [4]); กลับ x/y; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); ลอง {int x = d.div (4,0); System.out.println ("x ="+x); } catch (arithmeticexception e) / *หารวัตถุข้อยกเว้นได้รับการดำเนินการครั้งแรกคือ * / {system.out.println ("ตัวหารที่หย่าร้าง"); // รับข้อมูลข้อยกเว้น, ชื่อข้อยกเว้น System.out.println (e.toString ()); System.out.println ("over"); } catch (arrayIndexoutofboundsexception e) / *รับวัตถุที่มีข้อมูลออกจากขอบเขตการดำเนินการครั้งที่สองคือ * / {system.out.println ("Arrayout"); // output Exception Information System.out.println (e.toString ()); } catch (Exception e) /*รับข้อยกเว้นคลาสแม่และดำเนินการในที่สุด ขอแนะนำไม่ให้เขียนสิ่งนี้ให้โปรแกรมยุติ*//*ใช้ polymorphism*/ {system.out.println (e.toString ()); -

ผลการทำงาน:

อาร์เรย์อยู่นอกขอบเขต
java.lang.arrayIndexoutofboundsexception: 4

คำแนะนำ:

เมื่อทำการประมวลผลคุณต้องกำหนดวิธีการประมวลผลเฉพาะในการจับ

อย่าเพิ่งกำหนด E.PrintStackTrace ()

อย่าเพิ่งเขียนคำสั่งเอาต์พุต

เนื่องจากผู้ใช้ไม่สามารถเข้าใจได้จึงเป็นการดีที่สุดที่จะบันทึกไว้ในไฟล์และส่งไปยังนักพัฒนาของเราเพื่อดูเป็นประจำ

ตัวอย่างที่ 5: ข้อยกเว้นที่กำหนดเอง

คุณสังเกตเห็นว่าข้อยกเว้นที่เราใช้นั้นถูกห่อหุ้มทั้งหมดใน Java

อย่างไรก็ตามในการพัฒนาจริงข้อยกเว้นที่ปรากฏในโปรแกรมของเราอาจเป็นไปได้ว่า Java ไม่ได้ถูกห่อหุ้ม

ในเวลานี้คุณต้องกำหนดด้วยตัวคุณเอง

ตามรหัสข้างต้นฉันกำหนดว่าตัวหารไม่สามารถเป็นจำนวนลบได้ รหัสมีดังนี้

 การสาธิตคลาส {public int div (int x, int y) พ่น fushuexception/*ข้อยกเว้นด้านบน*/{ถ้า (y <0) {โยน fushuexception ใหม่ ("ตัวส่วนมีจำนวนลบ ------/bu fushu", y); /*วัตถุที่โยนข้อยกเว้นด้วยตนเอง*/} ส่งคืน x/y; }} คลาส fushuexception ขยายข้อยกเว้น {ค่า int ส่วนตัว; fushuexception (สตริง m, ค่า int) {super (m); /*พารามิเตอร์ผ่านไปยังวิธี getMessage ของข้อยกเว้นคลาสแม่*/ this.value = value; } public int getValue () /*วิธีการที่กำหนดเองส่งคืนหมายเลขลบ* / {ค่าคืน; }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); ลอง {int x = d.div (4, -3); System.out.println ("x ="+x); } catch (fushuexception e) /*catch object* / {system.out.println (e.getMessage ()+e.getValue ()); } system.out.println ("over"); -

ผลการทำงาน:

จำนวนลบจะปรากฏในตัวส่วน ------/bu fushu-3
เกิน

จากผลลัพธ์ข้างต้นเราจะเห็น

ในโปรแกรมนี้ตัวหารคือ -3 ซึ่งถือว่าผิดและไม่สามารถทำได้

จากนั้นคุณต้องมีคำอธิบายที่กำหนดเองของปัญหานี้

เมื่อขว้างวัตถุข้อยกเว้นภายในฟังก์ชั่นปรากฏขึ้นจะต้องมีการดำเนินการประมวลผลที่สอดคล้องกัน

หรือจัดการภายใน

ประกาศฟังก์ชั่นสำหรับผู้โทรเพื่อจัดการ

โดยทั่วไปแล้วข้อยกเว้นจะปรากฏในฟังก์ชั่นและจำเป็นต้องประกาศในฟังก์ชั่น

พบว่ามีเพียงชื่อข้อยกเว้นในผลลัพธ์ที่พิมพ์ออกมา แต่ไม่มีข้อมูลข้อยกเว้น

เนื่องจากข้อยกเว้นที่กำหนดเองไม่ได้กำหนดข้อมูล

จะกำหนดข้อมูลข้อยกเว้นได้อย่างไร?

เนื่องจากการดำเนินการของข้อมูลข้อยกเว้นเสร็จสมบูรณ์ในชั้นเรียนหลัก
ดังนั้นคลาสย่อยจะต้องส่งผ่านข้อมูลข้อยกเว้นไปยังคลาสหลักเมื่อสร้างผ่านคำสั่ง Super
จากนั้นคุณสามารถรับข้อมูลข้อยกเว้นที่กำหนดเองได้โดยตรงผ่านวิธี getMessage

ข้อยกเว้นที่กำหนดเอง จะต้องเป็น ข้อยกเว้นการสืบทอดคลาสที่กำหนดเอง

สืบทอดเหตุผลข้อยกเว้น:

ระบบยกเว้นมีคุณสมบัติ: เนื่องจากทั้งคลาสข้อยกเว้นและวัตถุข้อยกเว้นถูกโยนทิ้ง

พวกเขาทั้งหมดที่โยนได้ ความสามารถในการขยายตัวนี้เป็นคุณสมบัติที่เป็นเอกลักษณ์ของระบบที่สามารถขยายได้

เฉพาะคลาสและวัตถุในระบบนี้เท่านั้นที่สามารถดำเนินการได้โดยการโยนและโยน

ความแตกต่างระหว่างการโยนและการโยน

การขว้างจะใช้กับฟังก์ชั่น

การโยนถูกใช้ภายในฟังก์ชั่น

คลาสข้อยกเว้นตามด้วยการโยน สามารถตามด้วยหลาย คั่นด้วยเครื่องหมายจุลภาค

การโยนตามด้วยวัตถุข้อยกเว้น

ตัวอย่างที่ 6: มีข้อยกเว้นคลาสย่อยพิเศษในข้อยกเว้น RuntimeException

หากข้อยกเว้นถูกโยนลงในเนื้อหาฟังก์ชั่นสามารถประกาศฟังก์ชั่นได้โดยไม่ต้องประกาศและการรวบรวมจะถูกส่งผ่าน

หากมีการประกาศข้อยกเว้นในฟังก์ชั่นผู้โทรไม่สามารถประมวลผลได้และการรวบรวมจะดำเนินการผ่าน

เหตุผลที่ไม่จำเป็นต้องประกาศฟังก์ชั่นคือผู้โทรไม่จำเป็นต้องจัดการ

เมื่อข้อยกเว้นนี้เกิดขึ้นฉันหวังว่าโปรแกรมจะหยุดเพราะมันไม่สามารถทำงานได้ในระหว่างการทำงาน ฉันหวังว่าโปรแกรมจะหยุดหลังจากโปรแกรมจะหยุด

โปรแกรมเมอร์แก้ไขรหัส

 การสาธิตคลาส {public int div (int x, int y) พ่น fushuexception/*ผลลัพธ์ของการขว้างหรือไม่ขว้างเป็นเหมือนกัน*/{ถ้า (y <0) {โยน fushuexception ใหม่ ("ตัวส่วนมีจำนวนลบ ------/bu fushu", y); } return x/y; }} คลาส fushuexception ขยาย runtimeException /*การสืบทอด runtimeException* /{fushuexception (สตริง m, ค่า int) {super (m); }} class exceptionDemo {โมฆะคงที่สาธารณะหลัก (สตริง args []) {demo d = demo ใหม่ (); int x = d.div (4, -3); /*ข้อยกเว้นจะปรากฏขึ้นหลังจากเรียกใช้สิ่งนี้จะไม่มีปัญหากับการรวบรวม*/ system.out.println ("x ="+x); System.out.println ("over"); -

ผลการทำงาน:

ข้อยกเว้นในเธรด "Main" Fushuexception: จำนวนลบปรากฏในตัวส่วน ------/bu fushu
ที่ demo.div (ExceptionDemo.java:7)
ที่ ExceptionDemo.Main (ExceptionDemo.java:26)

จากผลลัพธ์ข้างต้นเราจะเห็น:

เมื่อข้อยกเว้นที่กำหนดเอง: หากข้อยกเว้นเกิดขึ้นการดำเนินการจะไม่ดำเนินการต่อ
ปล่อยให้ข้อยกเว้นที่กำหนดเองสืบทอด RuntimeException

สำหรับข้อยกเว้นมีสองประเภท:

1. ตรวจพบข้อยกเว้นระหว่างการรวบรวม

2. ข้อยกเว้นที่ไม่พบในระหว่างการรวบรวม (ข้อยกเว้นรันไทม์ RuntimeException และคลาสย่อยของมัน)

บทความข้างต้นเข้าใจกลไกการจัดการข้อยกเว้นใน Java เป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่ามันจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น