जावा अपवाद और उन्हें कैसे संभालें

जावा डेवलपर के रूप में, आपको जावा अपवादों और अपवाद प्रबंधन का अच्छा ज्ञान होना चाहिए।

यह ट्यूटोरियल मूल ज्ञान प्रदान करता है जो जावा प्रोग्राम के साथ काम करते समय प्रत्येक प्रोग्रामर के पास होना चाहिए। शुरू करने के लिए, आइए समझते हैं कि वास्तव में जावा अपवाद क्या हैं।

Java Exceptions क्या हैं

एक जावा प्रोग्राम समस्याओं में चल सकता है जिसके परिणामस्वरूप प्रोग्राम को उसके निष्पादन के दौरान अचानक समाप्त कर दिया जाता है। इन समस्याओं को अपवाद कहा जाता है।

एक अच्छा प्रोग्रामर निष्पादन के दौरान होने वाली त्रुटियों को पहचानने में सक्षम होना चाहिए और इस तरह के अपवाद के मामले में कार्यक्रम के लिए वैकल्पिक मार्ग प्रदान करना चाहिए। इस अभ्यास को अपवाद प्रबंधन कहा जाता है।

अब आप सोच रहे होंगे कि हमें अपवाद हैंडलिंग की आवश्यकता ही क्यों है। ऐसे प्रोग्राम क्यों न लिखें जो अपवाद नहीं फेंकेंगे?

हमें अपवाद प्रबंधन की आवश्यकता क्यों है

जैसा कि यह पता चला है, ऐसे प्रोग्राम लिखना जो अपवाद नहीं फेंकेंगे, उतना आसान नहीं है जितना लगता है। अधिकांश समय, ये अपरिहार्य त्रुटियां प्रोग्रामर के नियंत्रण से बाहर होती हैं।

उपयोगकर्ता इनपुट स्वीकार करने वाले प्रोग्राम अपवादों में चलने के लिए प्रवण होते हैं क्योंकि उपयोगकर्ता द्वारा प्रदान किए गए अमान्य इनपुट के कारण। तो बाहरी फाइलों को इस संभावना पर विचार कर रहा है कि उन्हें प्रोग्रामर की जानकारी के बिना किसी बाहरी स्रोत द्वारा स्थानांतरित, नाम बदला या हटा दिया गया है।

ऐसे मामलों में, प्रोग्राम को निष्पादन को समाप्त किए बिना अपवाद को इनायत से संभालने में सक्षम होना चाहिए।

जावा अपवादों का पदानुक्रम

जावा में सभी अपवाद Exception . के बच्चे होने चाहिए वर्ग, जो स्वयं Throwable . का एक बच्चा है कक्षा।

Exception के दो मुख्य उपवर्ग वर्ग हैं RuntimeException और IOException ।

अपवाद बनाम त्रुटि

Throwable . का एक अन्य चाइल्ड क्लास क्लास Error है कक्षा। हालाँकि, त्रुटियाँ अपवादों से भिन्न होती हैं।

त्रुटियां उन समस्याओं को इंगित करती हैं जो JVM निष्पादन के दौरान चल सकती हैं। ये समस्याएं आमतौर पर गंभीर और अपरिवर्तनीय होती हैं। मेमोरी लीक और लाइब्रेरी की असंगति के मुद्दे प्रोग्राम में त्रुटियों के सामान्य कारण हैं।

StackOverflowError और OutOfMemoryError जावा त्रुटियों के दो उदाहरण हैं।

चेक किए गए और अनचेक किए गए अपवाद

हम Java Exceptions को दो मुख्य श्रेणियों में विभाजित कर सकते हैं:चेक किया गया और अनचेक अपवाद।

चेक किए गए अपवाद वे अपवाद हैं जिन्हें संकलन से पहले प्रोग्राम में संभालने की आवश्यकता होती है। यदि इन अपवादों को संभाला नहीं जाता है, तो प्रोग्राम जावा कंपाइलर द्वारा संकलित नहीं किया जाएगा। इसलिए, इन्हें संकलन-समय अपवाद भी कहा जाता है। IOException चेक किए गए अपवादों के अच्छे उदाहरण हैं।

अनियंत्रित अपवाद वे अपवाद हैं जिन्हें संकलक प्रोग्राम को संकलित करते समय अनदेखा करता है। हमने प्रोग्राम में इन अपवादों को संभाला है या नहीं, इससे कोई फर्क नहीं पड़ता कि प्रोग्राम कब संकलित किया गया है। चूंकि इन अपवादों पर अपवाद प्रबंधन नहीं लगाया गया है, इसलिए हमारा प्रोग्राम RuntimeExceptions . में चल सकता है जिसके परिणामस्वरूप कार्यक्रम समाप्त हो जाता है।

RuntimeException का विस्तार करने वाले सभी वर्ग वर्ग अनियंत्रित अपवाद हैं। ऐसे वर्गों के दो उदाहरण हैं NullPointerException और ArrayIndexOutOfBoundsException ।

अपवाद वर्ग में सामान्य रूप से प्रयुक्त विधियाँ

हम जावा Exception . में आमतौर पर उपयोग की जाने वाली कुछ विधियों के बारे में जानेंगे कक्षा:

1. getMessage :एक संदेश देता है जिसमें अपवाद के बारे में विवरण होता है।
2. printStackTrace :हुए अपवाद का स्टैक ट्रेस लौटाता है।
3. toString :वर्ग का नाम और संदेश लौटाता है जो getMessage . के साथ लौटाया जाता है विधि।

अपवादों को कैसे हैंडल करें

आइए देखें कि हम जावा में अपवादों को कैसे संभाल सकते हैं:

ट्राई-कैच

हम अपवादों को पकड़ सकते हैं और कोशिश-पकड़ . का उपयोग करके उन्हें ठीक से संभाल सकते हैं जावा में ब्लॉक करें।

इस सिंटैक्स में, कोड का वह हिस्सा जो एक अपवाद को फेंकने के लिए प्रवण होता है, एक कोशिश ब्लॉक के अंदर रखा जाता है और कैच ब्लॉक/ब्लॉक फेंके गए अपवाद/अपवादों को पकड़ता है और हमारे द्वारा प्रदान किए गए तर्क के अनुसार उन्हें संभालता है।

ट्राइ-कैच ब्लॉक का मूल सिंटैक्स इस प्रकार है:

try {
    //exception-prone code
}
catch(Exception e) {
    //error handling logic
}

इस दृष्टिकोण के साथ, जब प्रोग्राम द्वारा अपवाद फेंका जाता है, तो प्रोग्राम निष्पादन को रोकता नहीं है, इसके बजाय, इसे इनायत से नियंत्रित किया जाता है।

हम देखेंगे कि IOExceptions को कैसे हैंडल किया जाता है FileReader . द्वारा फेंका गया जावा प्रोग्राम में क्लास।

उदाहरण:

import java.io.FileReader;

public class TryCatchBlockExample {

    public static void main(String[] args) {

        try {
            FileReader file = new FileReader("source.txt");
            file.read();
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }
}

यहां, हमने FileNotFoundException . को संभालने के लिए सिंगल कैच ब्लॉक का उपयोग किया है FileReader को इंस्टेंट करते समय फेंक दिया जाता है क्लास और IOException read() . द्वारा फेंका गया FileReader . की विधि कक्षा।

ये दोनों अपवाद Exception . के बच्चे हैं कक्षा।

हम सिंगल ट्राई स्टेटमेंट के अंदर कोड द्वारा फेंकी गई विभिन्न प्रकार की त्रुटियों को पकड़ने के लिए कई कैच स्टेटमेंट का भी उपयोग कर सकते हैं। पिछले उदाहरण के लिए, हम FileNotFoundException . को पकड़ने के लिए एक कैच ब्लॉक का उपयोग कर सकते हैं और IOException . के लिए एक और कैच ब्लॉक जैसा कि निम्न कोड स्निपेट दिखाता है:

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TryCatchBlockExample {

    public static void main(String[] args) {

        try {
            FileReader file = new FileReader("source.txt");
            file.read();
            file.close();
        }
        catch(FileNotFoundException e) {
            e.printStackTrace();
        }
        catch(IOException e) {
            e.printStackTrace();
        }
    }
}

यदि फेंका गया अपवाद पहले कैच स्टेटमेंट द्वारा हैंडल किए गए अपवाद से मेल खाता है, तो इसे पहले कैच स्टेटमेंट के अंदर लॉजिक द्वारा नियंत्रित किया जाता है।

यदि अपवाद मेल नहीं खाते हैं, तो इसे दूसरे कैच स्टेटमेंट में भेज दिया जाता है। यदि दो से अधिक कैच स्टेटमेंट हैं, तो यह प्रक्रिया तब तक जारी रहती है जब तक कि अपवाद कैच स्टेटमेंट तक नहीं पहुंच जाता है जो इसके प्रकार को पकड़ लेता है।

चूंकि FileNotFoundException IOException . का एक उपप्रकार है FileNotFoundException . को पकड़ने के लिए दूसरे कैच स्टेटमेंट का उपयोग करना काम नहीं करेगा। इसे पहले कैच स्टेटमेंट द्वारा नियंत्रित किया जाएगा और कभी भी दूसरे स्टेटमेंट तक नहीं पहुंचेगा।

आखिरकार

जब हम कोशिश-पकड़ . का उपयोग करते हैं हमारे कार्यक्रम में अपवादों को पकड़ने के लिए ब्लॉक, ऐसे उदाहरण हैं जिन्हें हम इस तथ्य के बावजूद कुछ तर्क लागू करना चाहते हैं कि कोई अपवाद पकड़ा गया था या नहीं। ऐसे मामलों में, हम आखिरकार प्रयास करें . का उपयोग कर सकते हैं केवल कोशिश करें . के बजाय अवरोधित करें ब्लॉक करें।

फिर, finally . के अंदर का कोड कथन लागू किया जाता है कि कोई अपवाद होता है या नहीं। finally स्टेटमेंट हमेशा ट्राइ-कैच-आखिरकार ब्लॉक के अंत में आना चाहिए।

उदाहरण के लिए, जब हम FileReader . का उपयोग करते हैं किसी फ़ाइल को पढ़ने के लिए वर्ग, प्रसंस्करण के अंत में खुली हुई फ़ाइल को बंद करना आवश्यक है चाहे कोई अपवाद हो या नहीं। इसे सुनिश्चित करने के लिए, हम फ़ाइल को finally . के अंदर बंद करने के लिए कोड डाल सकते हैं बयान।

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TryCatchFinallyBlockExample {

    public static void main(String[] args) {
        FileReader file = null;
        try {
            file = new FileReader("source.txt");
            file.read();
        }
        catch(FileNotFoundException e) {
            e.printStackTrace();
        }
        catch(IOException e) {
            e.printStackTrace();
        }
        finally {
            file.close();
        }
    }
}

हालाँकि, यदि आप उपरोक्त कोड को संकलित करने का प्रयास करते हैं, तो कोड को एक हैंडल न किए गए IOException के कारण संकलित नहीं किया जाएगा। . ऐसा इसलिए है क्योंकि close() FileReader . की विधि क्लास IOExceptions भी फेंक सकता है . तो, हमें इस हिस्से को इस तरह एक और कोशिश ब्लॉक के अंदर रखना होगा:

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TryCatchFinallyBlockExample {

    public static void main(String[] args) {
        FileReader file = null;

        try {
            file = new FileReader("source.txt");
            file.read();
        }
        catch(FileNotFoundException e) {
            e.printStackTrace();
        }
        catch(IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                file.close();
            }
            catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

फेंकता है

throws . का उपयोग करके त्रुटियों को संभालना जावा में कीवर्ड सरल है। वास्तव में, इस दृष्टिकोण में, आप वास्तव में उस स्थान पर अपवाद को संभाल नहीं पाते हैं जहां यह होता है। इसके बजाय, हम वर्तमान विधि से अपवाद को उस विधि में फेंक देते हैं जिसे वर्तमान विधि कहा जाता है। फिर, त्रुटि को सौंपना बाहरी विधि की जिम्मेदारी बन जाता है।

किसी अपवाद को किसी विधि से बाहर फेंकने के लिए, आपको बस यह घोषित करना होगा कि यह विधि माना अपवाद को फेंक सकती है। आइए देखें कि हम IOExceptions को कैसे हैंडल कर सकते हैं FileReader . द्वारा फेंका गया इस दृष्टिकोण का उपयोग कर वर्ग।

उदाहरण:

import java.io.FileReader;
import java.io.IOException;

public class ThrowsExample {

    public void readFile throws IOException {
        FileReader file = new FileReader("source.txt");
        file.read();
        file.close();
    }
}

फेंक दें

इस सूची में अन्य दृष्टिकोणों के विपरीत, throws त्रुटियों को संभालने के लिए कीवर्ड का उपयोग नहीं किया जाता है। लेकिन चूंकि अधिकांश लोग throws को भ्रमित करते हैं कीवर्ड के साथ throws कीवर्ड, हमने सोचा कि यहां इसकी चर्चा करना सबसे अच्छा होगा।

throw कीवर्ड का उपयोग स्पष्ट रूप से अपवाद का आह्वान करने के लिए किया जाता है। हम एक नया तत्काल अपवाद या एक अपवाद फेंक सकते हैं जो विधि के अंदर पकड़ा गया था।

public class ThrowExample {

    public void invalidate(int amount) throws Exception {
        if (amount < 500) {
            throw new Exception("Amount not sufficient");
        }
    }
}

उपयोगकर्ता-निर्धारित अपवाद

अंतर्निहित जावा अपवादों का उपयोग करने के अलावा, आप अपने स्वयं के अपवादों को परिभाषित कर सकते हैं। आप उन्हें चेक या अनचेक अपवादों के रूप में परिभाषित कर सकते हैं। एक नया चेक किया गया अपवाद बनाने के लिए, आपके नए अपवाद को Exception . का विस्तार करना चाहिए कक्षा।

एक अनचेक्ड . बनाने के लिए अपवाद, RuntimeException का विस्तार करें कक्षा।

निम्नलिखित कोड उदाहरण में, हमने एक उपयोगकर्ता-परिभाषित जाँच अपवाद बनाया है:

public class InvalidLengthException extends Exception {
    private int length;
    private String message;

    public InvalidLengthException(int length, String message) {
        this.length=length;
        this.message=message;
    }

    public int getAmount() {
        return this.length;
    }

    public String getMessage() {
        return this.message;
    }
}

अब हम उपरोक्त अपवाद को अपने प्रोग्राम लॉजिक के अंदर इस तरह उपयोग कर सकते हैं:

public class InputChecker {

    private int minLength;
    private int maxLength;

    public InputChecker(int minLength, int maxLength) {
        this.minLength=minLength;
        this.maxLength=maxLength;
    }

    public void checkStringLength(String strInput) throws InvalidLengthException {
        int strLength = strInput.length();
        if (strLength < minLength) {
            throw new InvalidLengthException(strLength, "Input should have minimum "+minLength+" characters");
        }
        else if (strLength > maxLength){
            throw new InvalidLengthException(strLength, "Input should have maximum "+maxLength+" character");
        }
    }
}

यदि हम InputChecker . का उपयोग करके स्ट्रिंग की लंबाई की जांच करते हैं वर्ग, यह एक InvalidLengthException फेंक देगा यदि स्ट्रिंग की लंबाई न्यूनतम लंबाई से कम या अधिकतम लंबाई से अधिक है।

public class Main {

    public static void main(String[] args) {
        InputChecker ic = new InputChecker(2, 7);
        try {
            ic.checkStringLength("longer than the maximum length");
        }
        catch(InvalidLengthException e) {
            e.printStackTrace();
        }
    }
}

जब हम उपरोक्त कोड स्निपेट चलाते हैं, तो यह एक InvalidLengthException . फेंक देगा और हमें निम्न आउटपुट मिलेगा:

InvalidLengthException: Input should have maximum 7 character
    at InputChecker.checkStringLength(InputChecker.java:17)
    at Main.main(Main.java:6)

निष्कर्ष

इस ट्यूटोरियल में, हमने आपको Java Exceptions का त्वरित और संक्षिप्त परिचय दिया है। हम आशा करते हैं कि अब आपको अपने जावा प्रोग्राम में अपवाद क्या हैं और उन्हें कैसे संभालना है, इसकी अच्छी समझ है।