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

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

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

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

คำสองสามคำเกี่ยวกับคำหลัก

การจัดการข้อยกเว้นใน Java ขึ้นอยู่กับการใช้คำหลักต่อไปนี้ในโปรแกรม:

• ลอง - กำหนดบล็อกของรหัสที่สามารถเกิดข้อยกเว้นได้
• catch - กำหนดบล็อกของรหัสที่มีการจัดการข้อยกเว้น
• สุดท้าย - กำหนดบล็อคทางเลือกของโค้ดที่หากมี จะถูกดำเนินการโดยไม่คำนึงถึงผลลัพธ์ของบล็อคการลอง

คำหลักเหล่านี้ใช้เพื่อสร้างโครงสร้างพิเศษในโค้ด: ลอง{}จับลอง{}จับ{}สุดท้ายลอง{}ในที่สุด{ }

• โยน - ใช้เพื่อยกข้อยกเว้น;
• โยน - ใช้ในลายเซ็นเมธอดเพื่อเตือนว่าเมธอดอาจโยนข้อยกเว้น

ตัวอย่างการใช้คีย์เวิร์ดในโปรแกรม Java:

// This method reads a string from the keyboard

public String input() throws MyException { // Use throws to warn
// that the method may throw a MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// We use a try block to wrap code that might create an exception. In this case,
// the compiler tells us that the readLine() method in the
// BufferedReader class might throw an I/O exception
    try {
        s = reader.readLine();
// We use a catch block to wrap the code that handles an IOException
    } catch (IOException e) {
        System.out.println(e.getMessage());
// We close the read stream in the finally block
    } finally {
// An exception might occur when we close the stream if, for example, the stream was not open, so we wrap the code in a try block
        try {
            reader.close();
// Handle exceptions when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// We've decided that an empty string will prevent our program from working properly. For example, we use the result of this method to call the substring(1, 2) method. Accordingly, we have to interrupt the program by using throw to generate our own MyException exception type.
        throw new MyException("The string cannot be empty!");
    }
    return s;
}

ทำไมเราต้องมีข้อยกเว้น?

ลองดูตัวอย่างจากโลกแห่งความเป็นจริง ลองนึกภาพว่าส่วนหนึ่งของทางหลวงมีสะพานเล็กๆ ที่รับน้ำหนักได้จำกัด ถ้ารถที่หนักกว่าสะพานขับมาทับ ก็อาจถล่มได้ สถานการณ์สำหรับคนขับจะกลายเป็น, พูดอย่างอ่อนโยน, เป็นพิเศษ. เพื่อหลีกเลี่ยงปัญหานี้ แผนกขนส่งได้ติดตั้งป้ายเตือนบนถนนก่อนที่จะมีสิ่งผิดปกติเกิดขึ้น เมื่อเห็นป้ายเตือน คนขับจะเปรียบเทียบน้ำหนักรถของตนกับน้ำหนักสูงสุดสำหรับสะพาน ถ้ารถหนักเกินไป คนขับใช้เส้นทางเลี่ยง ประการแรก แผนกขนส่งช่วยให้คนขับรถบรรทุกสามารถเปลี่ยนเส้นทางได้หากจำเป็น ประการที่สอง เตือนผู้ขับขี่เกี่ยวกับอันตรายบนถนนสายหลัก และประการที่สาม เตือนผู้ขับขี่ว่าห้ามใช้สะพานภายใต้เงื่อนไขบางประการ ความสามารถในการป้องกันและแก้ไขสถานการณ์พิเศษในโปรแกรม ทำให้โปรแกรมทำงานต่อไปได้ เป็นเหตุผลหนึ่งสำหรับการใช้ข้อยกเว้นใน Java กลไกข้อยกเว้นยังช่วยให้คุณปกป้องรหัส (API) ของคุณจากการใช้งานที่ไม่เหมาะสมด้วยการตรวจสอบความถูกต้อง (ตรวจสอบ) อินพุตใดๆ ลองนึกภาพว่าคุณเป็นแผนกขนส่งสักครู่ ขั้นแรก คุณต้องทราบสถานที่ที่ผู้ขับขี่รถยนต์อาจประสบปัญหาได้ ประการที่สอง คุณต้องสร้างและติดตั้งสัญญาณเตือน และสุดท้าย คุณต้องจัดเตรียมทางอ้อมหากมีปัญหาเกิดขึ้นบนเส้นทางหลัก ใน Java กลไกข้อยกเว้นทำงานในลักษณะเดียวกัน ในระหว่างการพัฒนา เราใช้try block เพื่อสร้าง "exception barriers" ในส่วนที่เป็นอันตรายของโค้ด เราจัดเตรียม "เส้นทางสำรอง" โดยใช้ catch {}บล็อก และเราเขียนโค้ดที่ควรรันไม่ว่าจะเกิดอะไรขึ้นในบล็อกสุดท้าย{} หากเราไม่สามารถจัดเตรียม "เส้นทางสำรอง" หรือเราต้องการให้สิทธิ์แก่ผู้ใช้ในการเลือก อย่างน้อยที่สุดเราต้องเตือนผู้ใช้ถึงอันตราย ทำไม ลองนึกภาพความไม่พอใจของคนขับที่มาถึงสะพานเล็กๆ ที่เขาข้ามไม่ได้โดยไม่เห็นป้ายเตือนสักอัน! ในการเขียนโปรแกรม เมื่อเขียนคลาสและเมธอดของเรา เราไม่สามารถคาดการณ์ล่วงหน้าได้เสมอว่า Developer คนอื่นๆ จะใช้งานคลาสเหล่านี้อย่างไร ด้วยเหตุนี้ เราจึงไม่สามารถคาดการณ์วิธีที่ถูกต้อง 100% ในการแก้ไขสถานการณ์พิเศษได้ ที่กล่าวว่าเป็นรูปแบบที่ดีในการเตือนผู้อื่นเกี่ยวกับความเป็นไปได้ของสถานการณ์พิเศษ กลไกข้อยกเว้นของ Java ช่วยให้เราทำสิ่งนี้ได้ด้วยการโยนคำหลัก — โดยพื้นฐานแล้วเป็นการประกาศว่าพฤติกรรมทั่วไปของวิธีการของเรารวมถึงการส่งข้อยกเว้น ดังนั้นใครก็ตามที่ใช้วิธีการนี้จะรู้ว่าเขาหรือเธอควรเขียนโค้ดเพื่อจัดการกับข้อยกเว้น

เตือนผู้อื่นเกี่ยวกับ "ปัญหา"

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

ลำดับชั้นข้อยกเว้น

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

1. สถานการณ์ที่โปรแกรมไม่สามารถกู้คืนและดำเนินการต่อตามปกติได้
2. สถานการณ์ที่สามารถฟื้นตัวได้

กลุ่มแรกประกอบด้วยสถานการณ์ที่เกี่ยวข้องกับข้อยกเว้นที่สืบทอดมาจากคลาสError ข้อผิดพลาดเหล่านี้เกิดขึ้นเนื่องจากการทำงานผิดพลาดของ JVM, หน่วยความจำล้น หรือระบบล้มเหลว พวกเขามักจะระบุถึงปัญหาร้ายแรงที่ซอฟต์แวร์ไม่สามารถแก้ไขได้ ใน Java คอมไพเลอร์ไม่ได้ตรวจสอบความเป็นไปได้ของข้อยกเว้นดังกล่าว ดังนั้นจึงเรียกว่าข้อยกเว้นที่ไม่ได้ตรวจสอบ กลุ่มนี้ยังรวมถึง RuntimeExceptions ซึ่งเป็นข้อยกเว้นที่สืบทอดมาจากข้อยกเว้นคลาสและสร้างโดย JVM ณ รันไทม์ มักเกิดจากข้อผิดพลาดในการเขียนโปรแกรม ข้อยกเว้นเหล่านี้จะไม่ถูกตรวจสอบ (ไม่เลือก) ในขณะคอมไพล์ ดังนั้นคุณไม่จำเป็นต้องเขียนโค้ดเพื่อจัดการ กลุ่มที่สองรวมถึงสถานการณ์พิเศษที่สามารถคาดการณ์ได้เมื่อคุณเขียนโปรแกรม (ดังนั้นคุณควรเขียนโค้ดเพื่อจัดการกับสิ่งเหล่านี้) ข้อยกเว้นดังกล่าวเรียกว่าข้อยกเว้นที่ตรวจสอบแล้ว เมื่อพูดถึงข้อยกเว้น งานส่วนใหญ่ของนักพัฒนา Java คือการจัดการกับสถานการณ์ดังกล่าว

การสร้างข้อยกเว้น

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

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

ใน Java เราสร้างบล็อคโค้ดที่เราคาดว่าจะต้องมีการจัดการข้อยกเว้นโดยใช้โครงสร้าง try{}catch , try{}catch{}finallyและtry{}finally{} เมื่อเกิดข้อยกเว้นใน บล็อก ลอง JVM จะมองหาตัวจัดการข้อยกเว้นที่เหมาะสมในบล็อกcatch ถัดไป ถ้าcatch block มีตัวจัดการข้อยกเว้นที่จำเป็น การควบคุมจะผ่านไปยังบล็อกนั้น ถ้าไม่เช่นนั้น JVM จะมองหาห่วงโซ่ของcatch block ต่อไปจนกว่าจะพบตัวจัดการที่เหมาะสม หลังจากดำเนินการcatch block การควบคุมจะถูกถ่ายโอนไปยังบล็อกสุดท้ายที่ เป็นทางเลือก ถ้าจับ ได้เหมาะไม่พบบล็อก จากนั้น JVM จะหยุดโปรแกรมและแสดงการติดตามสแต็ก (การเรียกเมธอดสแต็กปัจจุบัน) หลังจากดำเนิน การบล็อก สุดท้าย ในขั้นแรก หากมีอยู่ ตัวอย่างการจัดการข้อยกเว้น:

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside print method: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s : list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception handled. The program will continue");
            }
            finally {
                System.out.println("Inside finally block");
            }
            System.out.println("The program is running...");
            System.out.println("-----------------");
        }

    }
    }

นี่คือผลลัพธ์ของ วิธีการ หลัก :

Inside print method: first step
Inside finally block
The program is running...
-----------------
Exception: s is null!
Exception handled. The program will continue
Inside finally block
The program is running...
-----------------
Inside print method: second step
Inside finally block
The program is running...
-----------------

โดยทั่วไปจะใช้ คำสั่งสุดท้าย เพื่อปิดสตรีมและปล่อยทรัพยากรที่เปิด/จัดสรรในบล็อกลอง อย่างไรก็ตาม เมื่อเขียนโปรแกรม เราไม่สามารถติดตามการปิดทรัพยากรทั้งหมดได้เสมอไป เพื่อทำให้ชีวิตของเราง่ายขึ้น นักพัฒนาของ Java เสนอ โครงสร้าง try-with-resourcesซึ่งจะปิดทรัพยากรใดๆ ที่เปิดในtry block โดยอัตโนมัติ ตัวอย่างแรกของเราสามารถเขียนใหม่ได้ด้วยtry-with-resources :

public String input() throws MyException {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")) {
        throw new MyException ("The string cannot be empty!");
    }
    return s;
}

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

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("The string cannot be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

บรรทัดล่างสุด

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