ทุกที่ที่เราไป เหตุการณ์ที่คาดเดาไม่ได้กำลังรอเราอยู่ แผ่นดินไหว การกระทำที่ไร้เหตุผลของผู้คน อุกกาบาต... หรืออะไรที่ง่ายกว่านั้น เช่น หลอดไฟดับ บัตรธนาคารลดอำนาจแม่เหล็ก เกจวัดน้ำมันเบนซินแตก เราไม่สามารถปิดการใช้งานเหตุการณ์ที่คาดเดาไม่ได้ แต่อย่างน้อยเราก็สามารถเตรียมพร้อมบางส่วนสำหรับเหตุการณ์เหล่านั้นได้ นั่นคือเราต้องเตรียมกลไกบางอย่างเพื่อจัดการกับสิ่งเหล่านี้ ในโลกของการเขียนโปรแกรม โดยเฉพาะในภาษา Java เหตุการณ์ที่ขัดขวางไม่ให้โปรแกรมทำงานได้ตามปกติเรียกว่าข้อยกเว้น และกลไกในการป้องกันการหยุดทำงานของโปรแกรมเรียกว่าการจัดการข้อยกเว้น ดังนั้น เมื่อเกิดเหตุการณ์ที่ไม่คาดคิดในโปรแกรม เช่น การหารด้วยศูนย์ ก็ควรจะ "ทิ้ง" ข้อยกเว้นไว้ การจัดการข้อยกเว้นเป็นส่วนสำคัญของการเขียนโปรแกรม Java ที่ช่วยให้นักพัฒนาจัดการข้อผิดพลาดและข้อยกเว้นที่อาจเกิดขึ้นระหว่างการทำงานของโปรแกรม ในบทความนี้ เราจะเน้นไปที่หนึ่งในแนวคิดพื้นฐานของการจัดการข้อยกเว้น: คีย์เวิร์ด Throw ของ Java และวิธีใช้เพื่อโยนข้อยกเว้น
ข้อยกเว้นใน Java คืออะไร?
ข้อยกเว้นคือเหตุการณ์ที่เกิดขึ้นระหว่างการทำงานของโปรแกรมที่ขัดขวางโฟลว์ปกติของคำสั่งของโปรแกรม เมื่อมีข้อยกเว้นเกิดขึ้น การทำงานของโปรแกรมจะหยุดลง และข้อความแสดงข้อผิดพลาดจะแสดงบนคอนโซล ใน Java มีข้อยกเว้นสองประเภท: เลือกและยกเลิกการเลือก ข้อยกเว้นที่ถูกตรวจสอบจะถูกตรวจสอบ ณ เวลาคอมไพล์ และคอมไพลเลอร์ช่วยให้แน่ใจว่าข้อยกเว้นเหล่านั้นถูกจับหรือประกาศโดยวิธีการเรียก ในทางกลับกัน ข้อยกเว้นที่ไม่ได้ตรวจสอบจะไม่ได้รับการตรวจสอบ ณ เวลาคอมไพล์ และสามารถตรวจจับได้หรือไม่ปล่อยทิ้งไว้ นี่คือตัวอย่างโค้ดที่อาจเกิดข้อผิดพลาด แต่คอมไพลเลอร์ข้ามไปpublic class Factorial {
public static long getFactorial(final int number) {
long fact = 1;
for (int i = 1; i <= number; i++) {
fact = fact * i;
}
return fact;
}
public static void main(String[] args) {
System.out.println(getFactorial(-5));
System.out.println(getFactorial(21));
}
}
นี่คือผลลัพธ์ของโปรแกรม:
1 -4249290049419214848
โปรแกรมออกอย่างถูกต้อง แต่ให้ผลลัพธ์ที่ไม่ถูกต้อง ในกรณีแรก เนื่องจากอาร์กิวเมนต์ของฟังก์ชันเป็นค่าลบ และแฟกทอเรียลใช้ไม่ได้กับจำนวนลบ ในกรณีที่สอง ผลลัพธ์ไม่ถูกต้อง เนื่องจากตัวเลขมากเกินไปที่จะนับแฟคทอเรียลในช่วงของชนิดยาว นี่เป็นอีกตัวอย่างหนึ่ง ลองเขียนโปรแกรมโดยเราจะหารตัวเลขหนึ่งด้วยอีกจำนวนหนึ่ง
public class DivisionExample {
public static void main(String[] args) {
int a = 10;
int b = 0;
int result = divide(a, b);
System.out.println(result);
}
public static int divide(int a, int b) {
return a / b;
}
}
ในตัวอย่างนี้ArithmeticExceptionจะถูกส่งออกไปเนื่องจากตัวแปร b เป็นศูนย์ อย่างไรก็ตาม ข้อผิดพลาดนี้ไม่ได้รับการจัดการ ดังนั้นโปรแกรมจึงออกโดยมีสถานะไม่ถูกต้อง
วิธีการส่งข้อยกเว้นใน Java
ใน Java ข้อยกเว้นก็เป็นอ็อบเจ็กต์เช่นกัน ดังนั้นข้อยกเว้นจึงถูกส่งออกไปเหมือนกับอ็อบเจ็กต์ Exception ใหม่ที่สร้างขึ้น มีข้อยกเว้นเกิดขึ้นในโปรแกรมโดยใช้คำสั่ง Throw โดยปกติแล้ว การดำเนินการทั้งสองนี้ (การสร้างอ็อบเจ็กต์และการโยนข้อยกเว้น) จะรวมกันเป็นหนึ่งเดียว:throw new Exception("error…");
คีย์เวิร์ดThrowใน Java ใช้เพื่อโยนข้อยกเว้นจากเมธอดหรือบล็อกของโค้ด เมื่อมีข้อผิดพลาดหรือเงื่อนไขพิเศษเกิดขึ้นที่โปรแกรมไม่สามารถจัดการได้ในขณะรันไทม์ โฟลว์ของโปรแกรมถูกเปลี่ยนเส้นทางไปยังบล็อก catch ที่ใกล้ที่สุด บล็อกนี้สามารถจัดการข้อยกเว้นได้
ตัวอย่างการใช้คีย์เวิร์ด 'throw'
เพื่ออธิบายการทำงานของ คีย์เวิร์ด Throwใน Java เรามาลองดูตัวอย่างกัน มาเขียนวิธีคำนวณแฟกทอเรียลของตัวเลขกัน หากตัวเลขเป็นลบ จะไม่สามารถคำนวณได้ จึงต้องทิ้งข้อยกเว้น ในทำนองเดียวกัน หากตัวเลขมากเกินไป ผลลัพธ์แฟกทอเรียลจะเกินขนาดสูงสุดของประเภทยาว และข้อยกเว้นอื่นจะถูกส่งออกไป ที่นี่เรามีการนำวิธีการไปใช้:public Class Factorial {
public static long getFactorial(final int number) {
if ((number >= 0) && (number < 21)) {
long fact = 1;
for (int i = 1; i <= number; i++) {
fact = fact * i;
}
return fact;
} else {
//throw new exception here
throw new IllegalArgumentException("THe argument isn't legal");
}
}
public static void main(String[] args) {
System.out.println(getFactorial(-5));
System.out.println(getFactorial(21));
}
}
ในตัวอย่างนี้ ถ้าค่าของตัวเลขเป็นลบ คำสำคัญ โยนจะใช้ในการส่งอินสแตนซ์ของคลาสIllegalArgumentException หากคุณรันโปรแกรม ข้อความ "อาร์กิวเมนต์ไม่ถูกต้อง"จะแสดงบนคอนโซล การทำงานของโปรแกรมจะหยุดลง
ไม่มีข้อผิดพลาดอีกต่อไป: จับตัวอย่างข้อยกเว้น
ตอนนี้ เรามานึกถึงตัวอย่างที่สอง โดยหารด้วยศูนย์ และดำเนินการโดยใช้การจัดการข้อยกเว้นpublic class DivisionExample {
public static void main(String[] args) {
int a = 10;
int b = 0;
try {
int result = divide(a, b);
System.out.println(result);
} catch (ArithmeticException e) {
System.out.println("Error: division by zero");
}
}
public static int divide(int a, int b) {
return a / b;
}
}
ในตัวอย่างนี้ เราได้เพิ่ม โครงสร้าง try-catchเพื่อจัดการข้อยกเว้นการหารด้วยศูนย์ พูดสั้นๆ ก็คือtry-catch-finallyเป็นโครงสร้างภาษาการเขียนโปรแกรม Java ที่ช่วยให้คุณสามารถจัดการกับข้อยกเว้นและรันโค้ดได้ไม่ว่าจะมีข้อยกเว้นเกิดขึ้นหรือไม่ก็ตาม try-catch-finallyประกอบด้วยสามช่วงตึก:
- การลองบล็อก กำลังดำเนินการรหัสที่อาจเป็นอันตรายที่นี่ นั่นคือโค้ดที่สามารถส่งข้อยกเว้นได้ หากมีข้อยกเว้นเกิดขึ้นภายในtry block การเรียกใช้โค้ดในบล็อกนั้นจะถูกยกเลิก และการควบคุมจะถูกถ่ายโอนไปยัง catch block
- บล็อกจับ _ ที่นี่ข้อยกเว้นที่ส่งออกมาได้รับการจัดการ ในcatch block คุณสามารถระบุข้อยกเว้นที่จะตรวจจับและตรรกะใดที่จะดำเนินการเมื่อถูกจับได้ บ ล๊อก สุดท้ายแล้ว . สิ่งนี้จะถูกดำเนินการโดยไม่คำนึงว่ามีข้อยกเว้นเกิดขึ้นหรือไม่ บล็อกสุดท้ายถูกใช้ เช่น เพื่อปล่อยทรัพยากร (เช่น การปิดไฟล์หรือซ็อกเก็ต) ที่ได้รับการจัดสรรในบล็อกลอง คุณสามารถละเว้นบล็อกนี้ได้
พ่นคำสำคัญ
คำสำคัญ พ่นถูกใช้ในลายเซ็นวิธีการ ถ้าเป็นเช่นนั้น หมายความว่ามีข้อยกเว้นเกิดขึ้นในเมธอด สิ่งนี้สามารถเผยแพร่ข้อยกเว้นบน call stack และระบุว่าไม่จำเป็นต้องจัดการข้อยกเว้นในวิธีการปัจจุบัน ใน Java "พ่น" ยังสามารถใช้เพื่ออ้างถึงข้อยกเว้นแบบกำหนดเองที่กำหนดไว้ในโปรแกรม ตัวอย่างเช่น วิธีการอาจทำการหารตัวเลขสองตัว แต่จะส่งIllegalArgumentExceptionถ้าอาร์กิวเมนต์ที่สองเป็นศูนย์:public static double divide(double a, double b) throws IllegalArgumentException {
if (b == 0) {
throw new IllegalArgumentException("Division by zero is not allowed");
}
return a / b;
}
วิธีการนี้ใช้คำสำคัญพ่นเพื่อระบุว่าสามารถส่งIllegalArgumentException ได้ถ้าอาร์กิวเมนต์ที่สองเป็นโมฆะ หากเกิดข้อยกเว้นดังกล่าวขณะดำเนินการเมธอด ก็จะถูกส่งผ่านไปยังเมธอดการเรียกเพื่อประมวลผล ตัวอย่างการเรียกเมธอด:
public static void main(String[] args) {
double result = 0;
try {
result = divide(10, 0);
} catch (IllegalArgumentException e) {
System.out.println("Error: " + e.getMessage());
}
System.out.println("Result: " + result);
}
ในตัวอย่างนี้ วิธี การหาร ()ถูกเรียกด้วยอาร์กิวเมนต์ 10 และ 0 ซึ่งจะทำให้เกิดIllegalArgumentExceptionเนื่องจากการหารด้วยศูนย์เป็นไปไม่ได้ ข้อยกเว้นจะถูกตรวจจับโดย บล็อก try-catchและข้อความแสดงข้อผิดพลาดจะปรากฏขึ้น โปรแกรมจะให้ผลลัพธ์เป็นศูนย์เนื่องจากข้อยกเว้นยุติการดำเนินการของเมธอดdivide ()
GO TO FULL VERSION