क्यों पकड़

Question

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

} catch (SQLException sqle) { 
    sqle.printStackTrace(); 
} 
rs.close(); 
cs.close(); 

Answer 1

क्योंकि अगर एक अपवाद फेंक दिया जाता है try ब्लॉक के बाद कोई कोड जब तक अपवाद पकड़ा है निष्पादित किया जाता है। ब्लॉक हमेशा आपके निष्पादित होता है चाहे आपके try ब्लॉक के अंदर क्या होता है।

Answer 2

के बजाय इस

} catch (SQLException sqle) { 
    sqle.printStackTrace(); 
} finally { 
    cs.close(); 
    rs.close(); 
} 

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

Answer 3

आपका दूसरा दृष्टिकोण 'करीबी' कथन नहीं करेगा क्योंकि यह पहले ही विधि छोड़ चुका है।

Answer 4

अपने कैच ब्लॉक को देखें - यह DAOException फेंकने जा रहा है। तो आपके कैच ब्लॉक के बाद बयान को आपके द्वारा दिए गए नमूने में भी निष्पादित नहीं किया जा रहा है। जो आपने दिखाया है (दूसरे में एक अपवाद लपेटना) एक आम पैटर्न है - लेकिन एक और संभावना यह है कि पकड़ ब्लॉक "गलती से" अपवाद फेंकता है, उदा। क्योंकि कॉल में से एक यह विफल हो जाता है।

इसके अतिरिक्त, अन्य अपवाद भी हो सकते हैं पकड़ें - या तो क्योंकि आपने घोषणा की है कि विधि उन्हें फेंक देती है, या क्योंकि वे अनचेक अपवाद हैं। क्या आप वास्तव में संसाधनों को रिसाव करना चाहते हैं क्योंकि IllegalArgumentException कहीं फेंक दिया गया है?

Answer 5

इस तरह संसाधन लीक

Answer 6

अंत में ब्लॉक में कोड से पहले अपवाद कैच ब्लॉक से rethrown है कहा जाता हो जाएगा से बचना है। यह सुनिश्चित करता है कि अंत में ब्लॉक में आपके द्वारा डाले गए किसी भी क्लीनअप कोड को कॉल किया जाता है। आखिरकार ब्लॉक के बाहर कोड चलाया नहीं जाएगा।

Answer 7

अंतिम कीवर्ड गारंटी देता है कि कोड निष्पादित किया गया है। आपके निचले उदाहरण में, करीबी कथन निष्पादित नहीं किए जाते हैं। शीर्ष उदाहरण में, वे क्रियान्वित कर रहे हैं (आप क्या चाहते हैं!)

Answer 8

इस स्पष्ट हो सकता है: http://www.java2s.com/Code/Java/Language-Basics/Finallyisalwaysexecuted.htm

Answer 9

क्योंकि एक अपवाद अंत में खंड के रूप में निष्पादित करेंगे में फेंक दिया जाता है,

• कोड अपवाद बाहर की ओर फैलता है, भले ही अपवाद शेष विधि निष्पादन को रोकता है;

• कोशिश/पकड़ ब्लॉक के बाद कोड निष्पादित नहीं किया जाएगा जब तक अपवाद को पकड़ने वाले ब्लॉक द्वारा पकड़ा नहीं जाता है और पुनर्स्थापित नहीं किया जाता है।

Answer 10

पर विचार करें कि कॉल कॉल स्टैक में उच्च स्तर के कार्यों के लिए अपवाद फेंक सकता है। ऊपरी स्तर पर अपवाद फेंकने से पहले यह कॉलिंग फाइनल का नेतृत्व करेगा।

Answer 11

http://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html में यह भ्रामक है (और सवाल उत्पन्न हो सकता है):

The try block of the writeList method that you've been working with here opens a PrintWriter. The program should close that stream before exiting the writeList method. This poses a somewhat complicated problem because writeList's try block can exit in one of three ways.

1. The new FileWriter statement fails and throws an IOException. 
2. The list.get(i) statement fails and throws an IndexOutOfBoundsException. 
3. Everything succeeds and the try block exits normally. 

4 रास्ता (एक अपवाद IOException और IndexOutOfBoundsException के अलावा अन्य फेंक दिया जाता है) याद आ रही है। पिछले पृष्ठ में चित्रित कोड केवल finally का उपयोग करने से पहले (1) और (2) पकड़ता है।

मैं जावा के लिए भी नया हूं और इस आलेख को ढूंढने से पहले भी यही प्रश्न पूछ रहा था। लेटेंट मेमोरी सामान्य रूप से सिद्धांत के मुकाबले उदाहरणों के लिए खुद को अधिक संलग्न करती है।

Answer 12

आखिरकार ब्लॉक हमेशा नहीं चल सकता है, निम्न कोड पर विचार करें।

public class Tester { 
    public static void main(String[] args) { 
     try { 
      System.out.println("The main method has run"); 
      System.exit(1); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } finally { 
      System.out.println("The finally block has run"); 
     } 
    } 
} 

आपके मामले में, मैं अंदर अंत में ट्राई/कैच में ब्लॉक कोड, रैप करने के लिए के रूप में इस कोड जाहिरा तौर पर एक अपवाद फेंक कर सकते हैं सुझाव है।

} catch (SQLException sqle) { 
     sqle.printStackTrace(); 
    } finally { 
    try { 
     cs.close(); 
     rs.close(); 
    } catch (Exception e) { 
     //handle new exception here 
    } 

Answer 13

आप सभी त्रुटियों को पकड़ने है, वहाँ कोई अंतर नहीं है, अन्यथा, केवल कोड के अंदर अंत में ब्लॉक निष्पादित किया जाता है चाहिए, क्योंकि कोड निष्पादन अनुक्रम है: अंत में कोड -> त्रुटि फेंक -> कोड के बाद पकड़ इसलिए, एक बार आपका कोड किसी भी अनचाहे त्रुटि को फेंक देता है, केवल आखिरकार कोड ब्लॉक अपेक्षित काम करता है।

Answer 14

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