यह जावा कोड एक विधि के बाहर घुंघराले ब्रेसिज़ ({}) में क्यों है?

Question

मैं एक जावा प्रमाणन परीक्षा के लिए तैयार हो रही है और मैं अभ्यास परीक्षणों में से एक में इस तरह कोड को देखा है:

class Foo { 
    int x = 1; 
    public static void main(String [] args) { 
     int x = 2; 
     Foo f = new Foo(); 
     f.whatever(); 
    } 
    { x += x; } // <-- what's up with this? 
    void whatever() { 
     ++x; 
     System.out.println(x); 
    } 
} 

मेरा प्रश्न है ... यह वैध एक विधि बाहर घुंघराले ब्रेसिज़ में कोड लिखने के लिए है ? इनके प्रभाव क्या हैं (अगर कोई है)?

Answer 1

here से उधार -

आम तौर पर, यदि आप एक निर्माता में एक उदाहरण चर प्रारंभ करने में कोड जाते थे। पर कन्स्ट्रक्टर का उपयोग करने के दो विकल्प हैं उदाहरण आवृत्ति प्रारंभ करें: प्रारंभकर्ता ब्लॉक और अंतिम विधियां। हर निर्माता में

{ 
    // whatever code is needed for initialization goes here 
} 

जावा कम्पाइलर प्रतियां प्रारंभकर्ता ब्लॉक: उदाहरण चर के लिए प्रारंभकर्ता ब्लॉक देखने के सिर्फ स्थिर प्रारंभकर्ता ब्लॉक की तरह है, लेकिन बिना static मुख्य शब्द। इसलिए, इस दृष्टिकोण का उपयोग कई रचनाकारों के बीच कोड के ब्लॉक को साझा करने के लिए किया जा सकता है।

आप here पर चर्चाओं को भी देखना चाहते हैं।

Answer 2

यह initializer block है। इसका उपयोग आवृत्ति चर सेट करने के लिए किया जाता है। रचनाकारों पर प्रारंभकर्ता ब्लॉक का उपयोग करने के लिए प्रेरणा अनावश्यक कोड लिखना रोकने के लिए है। जावा कंपाइलर प्रत्येक कन्स्ट्रक्टर में ब्लॉक की सामग्री की प्रतिलिपि बनाता है।

Answer 3

यह एक प्रारंभिक ब्लॉक है जिसे निष्पादित किया जाता है जबकि कक्षा का उदाहरण लोड/बनाया जा रहा है और इसका उपयोग कक्षा के सदस्य गुणों को आरंभ करने के लिए किया जाता है (जावा http://download.oracle.com/javase/tutorial/java/javaOO/initial.html देखें)। आप जितना चाहें उतने ब्लॉक प्राप्त कर सकते हैं और उन्हें ऊपर से नीचे तक तुरंत चालू किया जाएगा।

उदाहरण ब्लॉक के अतिरिक्त, आप स्थिर सदस्यों को प्रारंभ करने के साथ-साथ कई स्थिर ब्लॉक भी प्राप्त कर सकते हैं। वे इस प्रकार के रूप में घोषित किया जाएगा: कक्षा प्रारंभ की जा रही है

public class Initialization { 

    static int b = 10; 

    int a = 5; 

    static { 
     b = -9; 
    } 

    { 
     a += 2; 
    } 

    public static void main(String[] args) throws Exception { 

     System.out.println(ClientVoting.b); 
     System.out.println(new ClientVoting().a); 
     System.out.println(ClientVoting.b); 
     System.out.println(new ClientVoting().a); 

    } 

    static { 
     b = 1; 
    } 

    { 
     a++; 
    } 
} 

, वहीं स्थिर सदस्य "बी" 10 के रूप में आरंभ नहीं हो जाता है, तो पहले स्थिर गुंजाइश -9 के लिए अपने मूल्य बदलता है, और बाद में 1. यह करने के लिए क्लास लोड होने पर केवल एक बार निष्पादित किया जाता है। यह मुख्य विधि की पहली पंक्ति के प्रारंभ से पहले निष्पादित करता है।

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

इस उदाहरण के लिए उत्पादन 1 8 1 8