การจัดการข้อยกเว้นใน Java

ข้อยกเว้นคืออะไร Java?

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

ข้อผิดพลาดสามารถแบ่งออกได้เป็นสองประเภทใหญ่ๆ Java:

1. ข้อผิดพลาดในการคอมไพล์เวลา
2. ข้อผิดพลาดรันไทม์

ข้อผิดพลาดขณะคอมไพล์สามารถแบ่งออกได้เป็นสองประเภทเพิ่มเติม:

• ข้อผิดพลาดทางไวยากรณ์
• ข้อผิดพลาดทางความหมาย

ตัวอย่างข้อผิดพลาดทางไวยากรณ์:

แทนที่จะประกาศ. int a; คุณประกาศผิดว่าเป็น in a;ซึ่งคอมไพเลอร์จะแสดงข้อผิดพลาด

ตัวอย่างข้อผิดพลาดทางความหมาย: คุณได้ประกาศตัวแปรแล้ว int a; และหลังจากโค้ดบางบรรทัด คุณจะประกาศจำนวนเต็มอีกครั้งเป็น int a;ข้อผิดพลาดทั้งหมดเหล่านี้จะถูกเน้นไว้เมื่อคุณคอมไพล์โค้ด

ตัวอย่างข้อผิดพลาดรันไทม์

ข้อผิดพลาดขณะรันไทม์ (Runtime error) เรียกว่า... ข้อยกเว้นข้อยกเว้นคือเหตุการณ์ใดๆ ที่ขัดจังหวะการทำงานปกติของโปรแกรม ตัวอย่างของข้อยกเว้น ได้แก่ ข้อยกเว้นทางคณิตศาสตร์, NullPointerException, ข้อยกเว้นการหารด้วยศูนย์ และอื่นๆ อีกมากมาย ข้อยกเว้นใน Java เป็นเงื่อนไขที่มักอยู่นอกเหนือการควบคุมโดยตรงของผู้พัฒนา

คลิก Good Farm Animal Welfare Awards หากไม่สามารถเข้าถึงวิดีโอได้

เหตุใดเราจึงต้องการการจัดการข้อผิดพลาด?

สมมติว่าคุณได้เขียนโปรแกรมเพื่อเข้าถึงเซิร์ฟเวอร์แล้ว ทุกอย่างทำงานได้ดีในขณะที่คุณกำลังพัฒนาping รันโค้ดในสภาพแวดล้อมภายในเครื่องที่มีการควบคุมเงื่อนไข

ในระหว่างการใช้งานจริง เซิร์ฟเวอร์อาจล่ม เมื่อโปรแกรมของคุณพยายามเข้าถึงเซิร์ฟเวอร์ จะเกิดข้อผิดพลาดขึ้น และหากไม่ได้รับการจัดการอย่างเหมาะสม โปรแกรมจะหยุดทำงานโดยไม่คาดคิด

วิธีจัดการกับข้อผิดพลาดใน Java

ที่ผ่านมาเราได้เห็นแล้วว่า ข้อผิดพลาดมักอยู่นอกเหนือการควบคุมของนักพัฒนา อย่างไรก็ตาม การโทษความล้มเหลวของโค้ดว่าเป็นเพราะปัญหาด้านสภาพแวดล้อมนั้นไม่ใช่ทางออกที่แท้จริง คุณจำเป็นต้องมีการเขียนโปรแกรมที่แข็งแกร่งซึ่งสามารถจัดการกับสถานการณ์ที่ผิดปกติได้ โค้ดดังกล่าวเรียกว่า... ตัวจัดการข้อยกเว้น.

ในตัวอย่างของเรา การจัดการข้อผิดพลาดที่ดีหมายความว่า เมื่อเซิร์ฟเวอร์หลักล่ม โปรแกรมจะเชื่อมต่อกับเซิร์ฟเวอร์สำรองโดยอัตโนมัติ

ในการดำเนินการนี้ คุณสามารถเขียนโค้ดเพื่อเชื่อมต่อกับเซิร์ฟเวอร์โดยใช้เงื่อนไข if และ else แบบดั้งเดิม คุณจะตรวจสอบว่าเซิร์ฟเวอร์ล่มหรือไม่ และถ้าใช่ คุณจะเขียนโค้ดเพื่อเชื่อมต่อกับเซิร์ฟเวอร์สำรอง การจัดระเบียบโค้ดโดยใช้เงื่อนไข "if" และ "else" แบบนี้ไม่ได้ผลเมื่อโค้ดของคุณมีหลายส่วน Java ข้อยกเว้น เพื่อจัดการ

class connect{
	if(Server Up){
	 // code to connect to server
	}
	else{
	 // code to connect to BACKUP server
	}
}

ลองใช้ Catch Block ใน Java

Java มีกลไกการจัดการข้อยกเว้นในตัวที่แยกตรรกะปกติออกจากตรรกะการกู้คืนข้อผิดพลาด

1. รหัสปกติจะเข้าสู่ a TRY กลุ่ม
2. รหัสการจัดการข้อยกเว้นจะอยู่ในไฟล์ จับ กลุ่ม

ในตัวอย่างนี้ บล็อก TRY จะประกอบด้วยโค้ดสำหรับเชื่อมต่อกับเซิร์ฟเวอร์หลัก ส่วนบล็อก CATCH จะประกอบด้วยโค้ดสำหรับเชื่อมต่อกับเซิร์ฟเวอร์สำรอง ในกรณีที่เซิร์ฟเวอร์หลักทำงานอยู่ โค้ดในบล็อก CATCH จะถูกละเว้น แต่ในกรณีที่เซิร์ฟเวอร์หลักล่ม จะเกิดข้อยกเว้นขึ้น และโค้ดในบล็อก CATCH จะถูกเรียกใช้งาน

นี่คือวิธีการจัดการกับข้อผิดพลาดใน Java.

ไวยากรณ์สำหรับการใช้ try และ catch

try{
    statement(s)
}
catch (exceptiontype name){
	statement(s)
}

ตัวอย่างการใช้บล็อก Try Catch

ขั้นตอน 1) คัดลอกโค้ดต่อไปนี้ลงในโปรแกรมแก้ไข

class JavaException {
   public static void main(String args[]){
      int d = 0;
      int n = 20;
      int fraction = n/d;
     System.out.println("End Of Main");
   }
}

ขั้นตอน 2) บันทึกไฟล์และคอมไพล์โค้ด จากนั้นรันโปรแกรมโดยใช้คำสั่ง java Javaข้อยกเว้น

ขั้นตอน 3) เกิดข้อผิดพลาดทางคณิตศาสตร์ (Arithmetic Exception) เนื่องจากการหารด้วยศูนย์ ในบรรทัดที่ 5 และบรรทัดที่ 6 จะไม่ถูกประมวลผล

ขั้นตอน 4) ต่อไปเราจะมาดูว่า try และ catch จะช่วยเราจัดการกับข้อยกเว้นนี้ได้อย่างไร เราจะใส่บรรทัดโค้ดที่ทำให้เกิดข้อยกเว้นไว้ใน try-catch ลอง บล็อกตามด้วย จับ บล็อก คัดลอกโค้ดต่อไปนี้ลงในตัวแก้ไข

class JavaException {
 public static void main(String args[]) {
  int d = 0;
  int n = 20;
  try {
   int fraction = n / d;
   System.out.println("This line will not be Executed");
  } catch (ArithmeticException e) {
   System.out.println("In the catch Block due to Exception = " + e);
  }
  System.out.println("End Of Main");
 }
}

ขั้นตอน 5) บันทึก คอมไพล์ และรันโค้ด คุณจะได้รับผลลัพธ์ดังต่อไปนี้

อย่างที่คุณสังเกตเห็น ข้อผิดพลาดได้รับการจัดการแล้ว และโค้ดบรรทัดสุดท้ายก็ถูกเรียกใช้งานด้วย นอกจากนี้ โปรดสังเกตว่าบรรทัดที่ 7 จะไม่ถูกเรียกใช้งานเนื่องจาก ทันทีที่มีข้อยกเว้นเกิดขึ้น การไหลของการควบคุมจะข้ามไปยังบล็อก catch

หมายเหตุ อ็อบเจ็กต์ ArithmeticException “e” เก็บข้อมูลเกี่ยวกับข้อผิดพลาดที่เกิดขึ้น ซึ่งมีประโยชน์เมื่อต้องการดำเนินการแก้ไข

Java ลำดับชั้นของคลาสข้อยกเว้น

หลังจากคำสั่ง catch หนึ่งคำสั่งทำงานเสร็จสิ้น คำสั่งอื่นๆ จะถูกข้ามไป และการทำงานจะดำเนินต่อไปหลังจากบล็อก try และ catch บล็อก catch ที่ซ้อนกันจะต้องปฏิบัติตามลำดับชั้นของข้อยกเว้นจากคลาสย่อยที่เฉพาะเจาะจงที่สุดไปยังคลาสแม่ที่ครอบคลุมที่สุด

• คลาสข้อยกเว้นทั้งหมดใน Java ขยายคลาส Throwable คลาส Throwable มีคลาสย่อยสองคลาส คือ Error และ Exception
• คลาส Error กำหนดข้อยกเว้นหรือปัญหาที่ไม่คาดว่าจะเกิดขึ้นภายใต้สถานการณ์ปกติในโปรแกรมของคุณ ตัวอย่างเช่น ข้อผิดพลาดเกี่ยวกับหน่วยความจำ ข้อผิดพลาดเกี่ยวกับฮาร์ดแวร์ หรือข้อผิดพลาดเกี่ยวกับ JVM
• คลาส Exception แทนข้อยกเว้นที่โปรแกรมของคุณสามารถจัดการได้ และโปรแกรมของคุณสามารถกู้คืนจากข้อยกเว้นเหล่านี้ได้โดยใช้บล็อก try และ catch
• RuntimeException เป็นคลาสย่อยของคลาส Exception Exception ประเภทนี้แสดงถึง Exception ที่ไม่ได้รับการตรวจสอบ ซึ่งเกิดขึ้นในขณะรันไทม์และไม่สามารถตรวจจับได้ในขณะคอมไพล์ ตัวอย่างที่ดีได้แก่ Exception การหารด้วยศูนย์ และ Exception ตัวชี้ว่าง (null pointer exception)
• IOException เกิดขึ้นระหว่างการดำเนินการรับและส่งข้อมูล
• ข้อผิดพลาดที่ถูกขัดจังหวะใน Java เกิดขึ้นเมื่อเธรดถูกขัดจังหวะระหว่างการทำงานแบบมัลติเธรด

ตัวอย่าง: การซ้อนบล็อก try และ catch

ขั้นตอน 1) คัดลอกโค้ดต่อไปนี้ลงในโปรแกรมแก้ไข

class JavaException {
 public static void main(String args[]) {
  try {
   int d = 1;
   int n = 20;
   int fraction = n / d;
   int g[] = {
    1
   };
   g[20] = 100;
  }
  /*catch(Exception e){
  	System.out.println("In the catch block due to Exception = "+e);
  }*/
  catch (ArithmeticException e) {
   System.out.println("In the catch block due to Exception = " + e);
  } catch (ArrayIndexOutOfBoundsException e) {
   System.out.println("In the catch block due to Exception = " + e);
  }
  System.out.println("End Of Main");
 }
}

ขั้นตอน 2) บันทึกไฟล์และคอมไพล์โค้ด จากนั้นเรียกใช้โปรแกรมโดยใช้คำสั่ง ชวา Javaข้อยกเว้น.

ขั้นตอน 3) เกิดข้อผิดพลาด ArrayIndexOutOfBoundsException ขึ้น ให้เปลี่ยนค่าของ int d เป็น 0 บันทึก คอมไพล์ และรันโค้ด

ขั้นตอน 4) จะต้องมีการสร้าง ArithmeticException ขึ้นมา

ขั้นตอน 5) ลบเครื่องหมายคอมเมนต์ออกจากบรรทัดที่ 10 ถึงบรรทัดที่ 12 บันทึก คอมไพล์ และรันโค้ด

ขั้นตอนที่ 6) เกิดข้อผิดพลาดในการคอมไพล์หรือไม่? เนื่องจาก Exception เป็นคลาสพื้นฐานของ ArithmeticException ข้อยกเว้นใดๆ ที่เกิดขึ้นจาก ArithmeticException ก็สามารถจัดการได้โดยคลาส Exception เช่นกัน ดังนั้นบล็อก catch ของ ArithmeticException จึงไม่มีโอกาสได้ทำงาน ทำให้มันซ้ำซ้อน ส่งผลให้เกิดข้อผิดพลาดในการคอมไพล์

Java ในที่สุดก็บล็อค

บล็อกสุดท้ายก็คือ ดำเนินการโดยไม่คำนึงถึงข้อยกเว้นที่เกิดขึ้น ในบล็อกลอง มันคือ ไม่จำเป็น ใช้ร่วมกับบล็อก try บล็อก finally เป็นสถานที่ที่เหมาะสมในการปล่อยทรัพยากรต่างๆ เช่น การเชื่อมต่อฐานข้อมูล ไฟล์ หรือซ็อกเก็ตเครือข่าย

 try {
  statement(s)
 } catch (ExceptiontType name) {

  statement(s)

 } finally {

  statement(s)

 }

หากเกิดข้อผิดพลาดขึ้นในบล็อก try บล็อก finally จะถูกดำเนินการหลังจากบล็อก catch ทำงานเสร็จสิ้น

ตัวอย่างของบล็อก finally

ขั้นตอน 1) คัดลอกโค้ดต่อไปนี้ลงในโปรแกรมแก้ไข

class JavaException {
   public static void main(String args[]){
    try{
       int d = 0;
       int n =20;
       int fraction = n/d;
    }
  catch(ArithmeticException e){
    System.out.println("In the catch block due to Exception = "+e);
  }
  finally{
	System.out.println("Inside the finally block");
  }
}
}

ขั้นตอน 2) บันทึก คอมไพล์ และรันโค้ด

ขั้นตอน 3) ผลลัพธ์ที่คาดหวัง: บล็อก finally จะถูกดำเนินการแม้ว่าจะเกิดข้อผิดพลาดขึ้นก็ตาม

ขั้นตอน 4) เปลี่ยนค่าของตัวแปร d เป็น 1 บันทึก คอมไพล์ และรันโค้ด แล้วสังเกตผลลัพธ์

แนวทางปฏิบัติที่ดีที่สุดสำหรับ Java การจัดการข้อยกเว้น

การปฏิบัติตามกฎที่ได้รับการพิสูจน์แล้วเพียงไม่กี่ข้อ จะช่วยให้คุณรักษาไว้ได้ Java โค้ดมีความทนทาน อ่านง่าย และแก้ไขข้อผิดพลาดได้ง่าย:

• ควรดักจับข้อยกเว้นที่เฉพาะเจาะจงที่สุดก่อน จากนั้นจึงดักจับข้อยกเว้นที่ทั่วไปกว่า เพื่อรักษาความสมบูรณ์ของลำดับชั้นของข้อยกเว้น
• หลีกเลี่ยงการใช้บล็อก catch ที่ว่างเปล่า อย่างน้อยที่สุด ควรบันทึกข้อผิดพลาดลงในล็อก เพื่อให้สามารถทราบสาเหตุที่แท้จริงได้เสมอ
• ใช้บล็อก finally หรือลองใช้ resources เพื่อปล่อยไฟล์ ซ็อกเก็ต และการเชื่อมต่อฐานข้อมูล
• ควรโยนข้อยกเว้นแบบตรวจสอบได้เฉพาะเมื่อผู้เรียกสามารถกู้คืนได้อย่างสมเหตุสมผล และใช้ข้อยกเว้นแบบไม่ตรวจสอบได้สำหรับข้อผิดพลาดในการเขียนโปรแกรม
• ห่อหุ้มข้อยกเว้นระดับต่ำด้วยข้อยกเว้นทางธุรกิจที่มีความหมาย เพื่อรักษาความต่อเนื่องของ APItracทำความสะอาดเรียบร้อยแล้ว
• ห้ามละเลย InterruptedException อย่างเงียบๆ ในโค้ดแบบมัลติเธรด ให้คืนค่าแฟล็กการขัดจังหวะแทน

คำถามที่พบบ่อย