एक इंस्टेंस प्रारंभकर्ता और कन्स्ट्रक्टर के बीच क्या अंतर है?

Question

बस इस तरह के संकलन कोड के कारण के बारे में सोच:

class MyClass extends AnotherClass { 
    { 
    MySecondClass object = new MySecondClass(); 
    object.doSomething(); 
    } 
} 

क्या इस कोड और निर्माता में कोड के बीच अंतर? यह कोड ऑब्जेक्ट सृजन से पहले निष्पादित करता है।

Answer 1

किसी भी नाम के साथ ब्रेसिज़ के अंदर कोड कक्षा के निर्माता का हिस्सा होगा और कक्षा निर्माता में निहित तर्क से पहले निष्पादित किया जाएगा।

त्वरित उदाहरण:

public class Foo { 
    { 
     System.out.println("Before Foo()"); 
    } 

    public Foo() { 
     System.out.println("Inside Foo()"); 
    } 

    { 
     System.out.println("Not After Foo()"); 
    } 
} 

Answer 2

यह वह जगह है एक उदाहरण प्रारंभ ब्लॉक कि निर्माता से पहले चलाता है और अगर आप से पूछना क्यों एक चाहता हूँ निर्माता के स्थान पर यह प्रयोग करेंगे? जवाब नहीं है, आप नहीं करते हैं।

बस इस तरह कोड संकलन के कारण के बारे में सोच:

आप आम तौर पर इसका इस्तेमाल आम कोड को अलग करने के लिए जब निर्माता अधिक भार का उपयोग कर। तो, "उपरोक्त वास्तव में ओवरलोडेड कन्स्ट्रक्टरों में से एक को संदर्भित करता है जिसे ऑब्जेक्ट इंस्टेंटेशन पर के बाद सामान्य इंस्टेंस प्रारंभिक कोड ब्लॉक निष्पादित किया गया है।

वैसे, आप कभी-कभी एक कन्स्ट्रक्टर को दूसरे से कॉल करके प्राप्त कर सकते हैं लेकिन कॉल को कॉलिंग कन्स्ट्रक्टर के अंदर पहली पंक्ति पर होना चाहिए या कोड संकलित नहीं होगा।

Answer 3

इसे इंस्टेंस प्रारंभकर्ता कहा जाता है। प्रारंभकर्ता में कोड के बाद सुपर क्लास कन्स्ट्रक्टर और पर कॉल शेष कन्स्ट्रक्टर कोड से पहले डाला गया है।

किसी भी कन्स्ट्रक्टर का पहला ऑपरेशन एक सुपर क्लास कन्स्ट्रक्टर का आह्वान करना है। यदि एक निर्माता को स्पष्ट रूप से कहा जाता है, super(...), निर्दिष्ट कन्स्ट्रक्टर का उपयोग किया जाता है। यदि कोई कन्स्ट्रक्टर स्पष्ट रूप से लागू नहीं किया गया है, तो सुपर क्लास में डिफ़ॉल्ट कन्स्ट्रक्टर (बिना तर्क के) का आह्वान किया जाता है। यदि ऐसा कोई कन्स्ट्रक्टर मौजूद नहीं है, तो यह एक संकलित समय त्रुटि है।

इस स्पष्ट या निहित रचनाकार आमंत्रण के बाद, उदाहरण प्रारंभकर्ताओं को स्रोत कोड में दिखाई देने के क्रम में बुलाया जाता है (हां, आपके पास एक से अधिक प्रारंभकर्ता हो सकते हैं)।

समझाने के लिए, इस कार्यक्रम चलाने प्रिंट

 
Another constructor 
Init 1 
Init 2 
Test constructor 

class Another { 
    Another() { System.out.println("Another constructor"); } 
} 

class Test extends Another { 

    public static void main(String[] args) { new Test(); } 

    { System.out.println("Init 1"); } 

    Test() { System.out.println("Test constructor"); } 

    { System.out.println("Init 2"); } 

} 

सबसे अधिक देखा आवेदन initalization "double brace initialization" idiom, जहां एक गुमनाम आंतरिक वर्ग परिभाषित किया गया है में है, और एक उदाहरण बनाया है और एक ही बार में कॉन्फ़िगर किया गया है।

JButton popupButton = new JButton(new AbstractAction("Popup") { 
    { 
    putValue(Action.SHORT_DESCRIPTION, "Popup a dialog"); 
    } 

    @Override 
    public void actionPerformed(ActionEvent evt) 
    { 
    popup(); 
    } 
}); 

यह यदि आप कई निर्माताओं है, और हर निर्माता में कुछ पैरामीटर कम प्रारंभ करने की आवश्यकता उपयोगी हो सकता है: यहाँ स्विंग प्रोग्रामिंग से एक बहुत ही आम उदाहरण है। इसे प्रारंभिक ब्लॉक में लगाया जा सकता है।