Java โยนข้อยกเว้น

ทุกที่ที่เราไป เหตุการณ์ที่คาดเดาไม่ได้กำลังรอเราอยู่ แผ่นดินไหว การกระทำที่ไร้เหตุผลของผู้คน อุกกาบาต... หรืออะไรที่ง่ายกว่านั้น เช่น หลอดไฟดับ บัตรธนาคารลดอำนาจแม่เหล็ก เกจวัดน้ำมันเบนซินแตก เราไม่สามารถปิดการใช้งานเหตุการณ์ที่คาดเดาไม่ได้ แต่อย่างน้อยเราก็สามารถเตรียมพร้อมบางส่วนสำหรับเหตุการณ์เหล่านั้นได้ นั่นคือเราต้องเตรียมกลไกบางอย่างเพื่อจัดการกับสิ่งเหล่านี้ ในโลกของการเขียนโปรแกรม โดยเฉพาะในภาษา 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));

   }

}

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

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 คุณสามารถระบุข้อยกเว้นที่จะตรวจจับและตรรกะใดที่จะดำเนินการเมื่อถูกจับได้
บ ล๊อก สุดท้ายแล้ว . สิ่งนี้จะถูกดำเนินการโดยไม่คำนึงว่ามีข้อยกเว้นเกิดขึ้นหรือไม่ บล็อกสุดท้ายถูกใช้ เช่น เพื่อปล่อยทรัพยากร (เช่น การปิดไฟล์หรือซ็อกเก็ต) ที่ได้รับการจัดสรรในบล็อกลอง คุณสามารถละเว้นบล็อกนี้ได้

โครงสร้าง try -catch-finallyช่วยให้สามารถควบคุมการทำงานของโปรแกรมได้แม่นยำยิ่งขึ้นในกรณีที่มีสถานการณ์พิเศษ และช่วยป้องกันการหยุดโปรแกรมโดยไม่คาดคิดในกรณีที่มีข้อผิดพลาด ตอนนี้ กลับมาที่ตัวอย่างของเรากัน หากการหารด้วยศูนย์เกิดขึ้นในระหว่างวิธีการหารArithmeticExceptionจะถูกส่งออกไป ซึ่งถูกจับโดย 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 ()