जावा में कई अपवादों को संभालने के लिए हम यह कर सकते हैं:

• मल्टीपल कैच ब्लॉक्स का उपयोग करें: यहां आप संबंधित ट्राई ब्लॉक के लिए मल्टीपल कैच ब्लॉक के तहत कई अपवादों को संभाल सकते हैं। प्रोग्राम फ्लो स्वचालित रूप से एक-एक करके कैच ब्लॉक में आ जाएगा और फिर, संबंधित कैच ब्लॉक को अपवाद के अनुसार पाया जाएगा और उसी के अनुसार संभाला जाएगा।
• एक कैच ब्लॉक के आर्ग्युमेंट्स में मल्टीपल कैच स्टेटमेंट्स का उपयोग करें: यह सुविधा जावा 7 से आई है। यहां आप संबंधित ट्राई ब्लॉक के लिए सिंगल कैच ब्लॉक (पाइप साइन द्वारा अलग) के तहत कई अपवादों को हैंडल कर सकते हैं। प्रोग्राम फ्लो स्वचालित रूप से कैच ब्लॉक में आ जाएगा और फिर, कैच ब्लॉक के तर्कों के अंदर इसी अपवाद को ट्राई ब्लॉक के लिए पाया जाएगा और उसी के अनुसार हैंडल किया जाएगा।

एकाधिक पकड़ ब्लॉक

जावा में, एक सिंगल ट्राई ब्लॉक में कई कैच ब्लॉक हो सकते हैं।

जावा में हमें एकाधिक कैच ब्लॉक की आवश्यकता क्यों है?

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

एक कोशिश ब्लॉक के बाद एक या अधिक कैच ब्लॉक हो सकते हैं। प्रत्येक कैच ब्लॉक में एक अलग अपवाद हैंडलर होना चाहिए। यदि इसमें एक अलग अपवाद हैंडलर है, तो आप अलग-अलग कैच ब्लॉक में अलग-अलग अपवादों को पकड़ सकते हैं। जब कोशिश ब्लॉक में एक अपवाद होता है, तो संबंधित कैच ब्लॉक जो उस विशेष अपवाद को निष्पादित करता है। इसलिए, यदि आपको अलग-अलग अपवाद होने पर अलग-अलग कार्य करने हैं, तो आप जावा में मल्टी-ट्राई कैच का उपयोग कर सकते हैं।

वाक्य - विन्यास

जावा में एक से अधिक कैच ब्लॉक के साथ एक ही कोशिश का उपयोग करने का सिंटैक्स इस प्रकार है:

try 
{ 
  statements; 
} 
catch(ExceptionType1 e1) 
{ 
  statements; 
} 
catch(ExceptionType2 e2) 
{ 
  statements; 
}

मामले में, फेंका गया अपवाद ऑब्जेक्ट पहले कैच ब्लॉक से मेल नहीं खाता है, दूसरा कैच ब्लॉक चेक करेगा, और इसी तरह।

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

मल्टी-कैच ब्लॉक का फ़्लोचार्ट

उदाहरण

उदाहरण 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException e) {
      System.out.println(e.getMessage());
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    } 
  }
}

/ by zero

• अंकगणितीय अपवाद क्योंकि हम किसी संख्या को 0 से विभाजित करने का प्रयास कर रहे हैं।
• ArrayIndexOutOfBoundException क्योंकि हमने 0 से 9 तक की सरणियों के साथ एक नया पूर्णांक सरणी घोषित किया है और हम अनुक्रमणिका 10 को एक मान निर्दिष्ट करने का प्रयास कर रहे हैं।

असाइनमेंट ऑपरेटर = की सहयोगीता दाएं से बाएं है, इसलिए एक अंकगणितीय अपवाद को पहले संदेश के साथ / शून्य से फेंक दिया जाता है।

उदाहरण 2

class Example2{
   public static void main(String args[]){
     try{
         int a[]=new int[7];
         a[4]=30/0;
         System.out.println("First print statement in try block");
     }
     catch(ArithmeticException e){
        System.out.println("Warning: ArithmeticException");
     }
     catch(ArrayIndexOutOfBoundsException e){
        System.out.println("Warning: ArrayIndexOutOfBoundsException");
     }
     catch(Exception e){
        System.out.println("Warning: Some Other exception");
     }
   System.out.println("Out of try-catch block...");
  }
}

Warning: ArithmeticException
Out of try-catch block...

एक अपवाद हैंडलर के साथ एक से अधिक प्रकार के अपवादों को पकड़ना

जावा 7 और बाद में, एक कैच ब्लॉक में कई अपवादों को संभालने के लिए कैच ब्लॉक में सुधार किया गया है। यदि आप कई अपवादों को पकड़ रहे हैं और उनके पास समान कोड है।

एक सिंगल कैच ब्लॉक में प्रत्येक को | से अलग करके कई अपवादों को संभालने (पकड़ने) की संभावना है (पाइप प्रतीक) कैच ब्लॉक में।

यह सुविधा कोड डुप्लिकेशन को कम कर सकती है और दक्षता में वृद्धि भी एक अत्यधिक व्यापक अपवाद को पकड़ने के लिए प्रलोभन को कम कर सकती है ।

निम्नलिखित उदाहरण पर विचार करें, जिसमें प्रत्येक कैच ब्लॉक में डुप्लिकेट कोड होता है:

catch (IOException ex) {
     logger.log(ex);
     ex.printStackTrace();
catch (SQLException ex) {
     logger.log(ex);
     ex.printStackTrace();
}

जावा एसई 7 और बाद में, हम इस दृष्टिकोण का उपयोग करके डुप्लिकेट किए गए कोड को समाप्त कर सकते हैं

वाक्य - विन्यास

क्लॉज में catch, उन अपवादों के प्रकारों को निर्दिष्ट करें जिन्हें ब्लॉक संभाल सकता है, और प्रत्येक अपवाद प्रकार को एक वर्टिकल बार ( |) से अलग करें:

try {
  // code
} catch (ExceptionType1 | Exceptiontype2 ex) { 
  // catch block
}

उदाहरण

उदाहरण 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

इस प्रोग्राम को संकलित करते समय उत्पन्न बायटेकोड कई कैच ब्लॉक वाले प्रोग्राम से छोटा होगा क्योंकि कोई कोड अतिरेक नहीं है।

नोट : यदि एक कैच ब्लॉक एक से अधिक अपवाद प्रकारों को संभालता है, तो कैच पैरामीटर निहित रूप से अंतिम होता है । इस उदाहरण में, कैच पैरामीटर एक्स अंतिम है और इसलिए आप इसे कैच ब्लॉक के भीतर कोई मान नहीं दे सकते।

यह दृष्टिकोण आमतौर पर उपयोग किया जाता है यदि आप कई अपवादों को पकड़ रहे हैं और उनके पास समान कोड है। लेकिन हम इसे अपनी पसंद के अनुसार भी इस्तेमाल कर सकते हैं।

उदाहरण 2

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException|ArrayIndexOutOfBoundsException e) {
      if (e instanceof ArithmeticException)
          System.out.println("ArithmeticException");
      else
          System.out.println("ArrayIndexOutOfBoundsException");
    }
  }
}

एक एकल कैच ब्लॉक में कई अपवादों को पकड़ने पर , नियम को विशिष्ट के लिए सामान्यीकृत किया जाता है।

इसका मतलब यह है कि अगर कैच ब्लॉक में अपवादों का एक पदानुक्रम है , तो हम कई विशिष्ट अपवादों को पकड़ने के बजाय केवल मूल अपवाद को पकड़ सकते हैं।

आइए एक उदाहरण लेते हैं।

उदाहरण 1: केवल आधार अपवाद वर्ग को पकड़ना

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

यदि बेस एक्सेप्शन क्लास पहले से ही कैच ब्लॉक में निर्दिष्ट किया गया है, तो उसी कैच ब्लॉक में चाइल्ड एक्सेप्शन क्लास का उपयोग न करें। अन्यथा, हमें एक संकलन त्रुटि मिलेगी।

आइए एक उदाहरण लेते हैं।

उदाहरण 2: आधार और बाल अपवाद वर्ग को पकड़ना

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception | ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

Main.java:6: error: Alternatives in a multi-catch statement cannot be related by subclassing

कार्यक्रम

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

// Demonstrate multiple catch statements.
class MultiCatch {
public static void main(String args[]) {
try {
    int a = args.length;
    System.out.println("a = " + a);
    int b = 42 / a;
    int c[] = { 1 };
    c[42] = 99;
} catch(ArithmeticException e) {
    System.out.println("Divide by 0: " + e);
} catch(ArrayIndexOutOfBoundsException e) {
    System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}

इसे दोनों तरीकों से चलाकर उत्पन्न आउटपुट यहां दिया गया है:

C:\>java MultiCatch
a = 0
Divide by 0: java.lang.ArithmeticException: / by zero
After try/catch blocks.
C:\>java MultiCatch TestArg
a = 1
Array index oob: java.lang.ArrayIndexOutOfBoundsException:42
After try/catch blocks.

/* This program contains an error.
A subclass must come before its superclass in
a series of catch statements. If not,
unreachable code will be created and a
compile-time error will result.
*/
class SuperSubCatch {
public static void main(String args[]) {
    try {
        int a = 0;
        int b = 42 / a;
    } catch(Exception e) {
        System.out.println("Generic Exception catch.");
    }
    /* This catch is never reached because
    ArithmeticException is a subclass of Exception. */
    catch(ArithmeticException e) { // ERROR - unreachable
        System.out.println("This is never reached.");
    }
}
}

Mouad Oumous Java WhatsApp Group JOIN में शामिल हों

Mouad Oumous टेलीग्राम चैनल JOIN से जुड़ें

सेमाफोर | जावा समवर्ती एपीआई जावा समवर्ती एपीआई पैकेज - भाग 1 जावा - 8 | BiFunction, BiConsumer और BiPredicate इंटरफ़ेस उदाहरण के साथ