के बीच क्या अंतर है
try {
fooBar();
} finally {
barFoo();
}
तथा
try {
fooBar();
} catch(Throwable throwable) {
barFoo(throwable); // Does something with throwable, logs it, or handles it.
}
मुझे दूसरा संस्करण बेहतर लगता है क्योंकि यह मुझे थ्रोबेबल तक पहुंच प्रदान करता है। क्या दो भिन्नताओं के बीच कोई तार्किक अंतर या एक पसंदीदा सम्मेलन है?
इसके अलावा, अंत में क्लॉज से अपवाद को एक्सेस करने का कोई तरीका है?
जवाबों:
ये दो अलग चीजें हैं:
अपने उदाहरण में आपने तीसरा संभावित निर्माण नहीं दिखाया है:
try {
// try to execute this statements...
}
catch( SpecificException e ) {
// if a specific exception was thrown, handle it here
}
// ... more catches for specific exceptions can come here
catch( Exception e ) {
// if a more general exception was thrown, handle it here
}
finally {
// here you can clean things up afterwards
}
और, जैसा @codeca अपनी टिप्पणी में कहता है, अंत में ब्लॉक के अंदर अपवाद को एक्सेस करने का कोई तरीका नहीं है, क्योंकि अंत में ब्लॉक को निष्पादित किया जाता है भले ही कोई अपवाद न हो।
बेशक आप एक वैरिएबल की घोषणा कर सकते हैं जो आपके ब्लॉक के बाहर अपवाद रखता है और कैच ब्लॉक के अंदर एक वैल्यू असाइन करता है। बाद में आप इस वैरिएबल को अपने अंतिम ब्लॉक के अंदर एक्सेस कर सकते हैं।
Throwable throwable = null;
try {
// do some stuff
}
catch( Throwable e ) {
throwable = e;
}
finally {
if( throwable != null ) {
// handle it
}
}
ये विविधताएं नहीं हैं, वे मौलिक रूप से अलग चीजें हैं। हमेशाfinally निष्पादित किया जाता है , केवल जब कोई अपवाद होता है।catch
अंत में और पकड़ ब्लॉक काफी अलग हैं:
इसलिए
try {
//some code
}
catch (ExceptionA) {
// Only gets executed if ExceptionA
// was thrown in try block
}
catch (ExceptionB) {
// Only executed if ExceptionB was thrown in try
// and not handled by first catch block
}
से भिन्न है
try {
//some code
}
finally {
// Gets executed whether or not
// an exception was thrown in try block
}
काफी।
यदि आप एक कोशिश ब्लॉक को परिभाषित करते हैं तो आपको परिभाषित करना होगा
तो निम्नलिखित कोड भी मान्य होगा:
try {
//some code
}
catch (ExceptionA) {
// Only gets executed if
// ExceptionA was thrown in try block
}
catch (ExceptionB) {
// Only executed if ExceptionB was thrown in
// try and not handled by first catch block
}
//even more catch blocks
finally {
// Gets executed whether or not an
// exception was thrown in try block
}
try एक विधि को चलाने के लिए उपयोग किया जाता है जो एक अपवाद को फेंक सकता है
catch इसका उपयोग उस अपवाद को "पकड़ने" के लिए किया जाता है
finally किसी भी क्लीन अप के लिए उपयोग किया जाता है जो अपवाद से पकड़ा जा रहा है या नहीं
try{
myObject.riskyMethod(); // run a method that may throw an exception
}
catch(Exception ex){
myLogger.log(ex.Message); // "catch" stop that exception
}
finally{
myObject = null; // clean up needed from that exception being caught
}
try {
statements;
} catch (exceptionType1 e1) { // one or multiple
statements;
} catch (exceptionType2 e2) {
statements;
}
...
} finally { // one or none
statements;
}
कोई बात नहीं जो अंततः ब्लॉक को हमेशा निष्पादित किया जाता है, इसलिए सामान्य तौर पर, अंत में ब्लॉक का उपयोग किया जाता है, जब आपके पास सत्र, डेटाबेस कनेक्शन या फाइलें या सॉकेट खुले होते हैं, तो उन कनेक्शनों को बंद करने के लिए कोड रखा जाएगा। यह सिर्फ एक आवेदन में कोई स्मृति लीक या किसी भी अन्य समस्याएँ नहीं होनी चाहिए सुनिश्चित करने के लिए है।
अंत में और पकड़ ब्लॉक काफी अलग हैं:
कैच ब्लॉक के भीतर आप फेंके गए अपवाद का जवाब दे सकते हैं। यह ब्लॉक केवल तभी निष्पादित किया जाता है जब कोई अखंड अपवाद हो और प्रकार एक से मेल खाता हो या कैच ब्लॉक के पैरामीटर में निर्दिष्ट एक का उपवर्ग हो। अंत में हमेशा कोशिश के बाद क्रियान्वित किया जाएगा और ब्लॉक को पकड़ा जाएगा कि कोई अपवाद उठाया गया है या नहीं।
आमतौर पर जब हम धाराओं, कनेक्शन आदि जैसे किसी भी संसाधन का उपयोग करते हैं .. तो हमें अंततः ब्लॉक का उपयोग करके उन्हें स्पष्ट रूप से बंद करना होगा। नीचे दिए गए प्रोग्राम में हम FileReader का उपयोग करके एक फ़ाइल से डेटा पढ़ रहे हैं और हम इसे अंततः ब्लॉक का उपयोग करके बंद कर रहे हैं।
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class ReadData_Demo {
public static void main(String args[]){
FileReader fr=null;
try{
File file=new File("file.txt");
fr = new FileReader(file); char [] a = new char[50];
fr.read(a); // reads the content to the array
for(char c : a)
System.out.print(c); //prints the characters one by one
}catch(IOException e){
e.printStackTrace();
}
finally{
try{
fr.close();
}catch(IOException ex){
ex.printStackTrace();
}
}
}
}
शायद मेरे जैसे अन्य लोगों ने कुछ इस तरह से खोजा।
इस पेज से सूचना tutpoint
यहां तक कि पहले रूप में आप इसे कॉलिंग विधि में लॉग कर सकते हैं। इसलिए कोई बड़ा फायदा नहीं है जब तक कि आप कुछ खास तरह की हैंडलिंग नहीं करना चाहते।
कोशिश करें कि ब्लॉक उन बयानों को आयोजित करेगा जो अपवाद को बढ़ाने जा रहे हैं। कैच ब्लॉक ट्राई ब्लॉक से फेंके गए रेफरेंस को होल्ड करेगा और कैच ब्लॉक से जरूरी मैसेज जेनरेट किए जाएंगे। अंत में ब्लॉक का उपयोग यूओ क्लोजिंग, फाइल क्लोजिंग, डीबी क्लोजिंग जैसे उपयोग किए गए संसाधनों को बंद करने के लिए भी किया जाता है। जावा -9 में एन्हांस्ड ट्राई-विथ रिसोर्स आया है, जहां संसाधनों को ट्राई के बाहर घोषित किया गया है। मुग्ध प्रयास संसाधन के साथ कैच ब्लॉक अनिवार्य है
ThrowablefinallyThrowable