संदर्भ चर पर कॉलिंग तरीकों एक नई वस्तु

Question

मैं एक गैर स्थिर विधि बुला में भ्रम की स्थिति हो रही है पर तरीकों कॉलिंग बनाम

class A { 
    void doThis() {} 

    public static void main(String... arg) { 
     A a1 = new A(); 
     a1.doThis();  // method - 1 
     new A().doThis(); // method - 2 
    } 
} 

मुझे पता है कि दोनों विधि -1 और विधि -2पर कॉल करेगा(), लेकिन क्या कोई कार्यात्मक अंतर है? विधि-2 में नई ऑब्जेक्ट का संदर्भ क्या होगा।

Answer 1

क्या कोई कार्यात्मक अंतर है?

दोनों एक ही तरीके से व्यवहार करेंगे।

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

return new Builder().a().b().build(); 

या किसी वस्तु बनाया गया था, तो केवल प्रदर्शन करने के लिए एक परिभाषित एक बार कार्रवाई

विधि -2 में एक नई वस्तु का संदर्भ क्या होगा?

यह अब मौजूद नहीं है (अधिक सटीक, हम इसे लिए पहुँच नहीं है) जब तक doThis रिटर्न this जो आप विधि निष्पादन के बाद एक चर में डाल करने में सक्षम हो सकता है।

क्या मैं कह सकता हूं कि विधि -2 गैर-स्थैतिक विधि को कॉल करने का एक अनुचित तरीका है?

नहीं। यदि हम इस चर का कभी भी उपयोग नहीं करेंगे तो हम एक चर क्यों बना सकते हैं?

Answer 2

देखते हैं क्या कोड सादे अंग्रेजी में कहते हैं करते हैं:

 A a1 = new A(); 
     a1.doThis(); 

1. ए
का एक नया उदाहरण
2. स्टोर चर a1 में इसे करने के लिए एक संदर्भ बनाएँ।
3. हमारे उदाहरण पर doThis() पर कॉल करें।

new A().doThis(); जबकि पढ़ता के रूप में:

1. हमारे उदाहरण पर ए
2. कॉल doThis() का एक नया उदाहरण बनाएँ।

तो केवल अंतर यह है कि क्या आप इसे स्थानीय चर में संग्रहीत करते हैं या नहीं। यदि आप चर में वैल्यू का उपयोग नहीं करते हैं, तो उस अंतर से कोई फर्क नहीं पड़ता। लेकिन अगर आप एक ही ऑब्जेक्ट पर एक ही ऑब्जेक्ट पर कॉल करना चाहते हैं, तो मान लें कि a1.doThat(), तो आप दूसरे समाधान के साथ परेशानी में हैं, क्योंकि आपको मूल उदाहरण का कोई संदर्भ नहीं मिला है।

आप एक ही ऑब्जेक्ट का उपयोग क्यों करना चाहते हैं? क्योंकि विधियां ऑब्जेक्ट की आंतरिक स्थिति को बदल सकती हैं, यह कि वस्तु के बारे में काफी कुछ है।

Answer 3

इन दोनों तरीकों एक के बाद एक पर एक नज़र देता है।

विधि-1

A a1 = new A(); 
a1.doThis(); 

में विधि-1, आप A के नव निर्मित उदाहरण के लिए एक संदर्भ है, यानी a1 और आप इस का उपयोग कर A के इस उदाहरण पर के रूप में कई तरीकों कॉल कर सकते हैं संदर्भ a1। मूल रूप से आप अपने संदर्भ a1 का उपयोग करके A के उस विशेष उदाहरण का पुन: उपयोग कर सकते हैं।

विधि-2

new A().doThis(); 

हालांकि विधि -2 में, आप किसी भी चर कि A की अपनी नई बनी उदाहरण के संदर्भ संग्रहीत करता है नहीं है। आप A के उस विशेष उदाहरण पर किसी भी अन्य विधि कॉल करने के लिए है, तो आप कैसे A के उस विशेष उदाहरण का उल्लेख होगा? आप A की कि उदाहरण के फिर से उपयोग करने में सक्षम अगर आप विधि-2 का उपयोग कर एक उदाहरण बना सकते हैं और के रूप में यह प्रयोग किया जाता है आप जितनी जल्दी हो कि उदाहरण खो देंगे नहीं होगा।

Answer 4

उन तरीकों के निष्पादन में कोई अंतर नहीं होगा, लेकिन new A().doThis() के मामले में आप किसी ऑब्जेक्ट के उदाहरण को संदर्भ खोने जा रहे हैं जिस पर आपने विधि लागू की है और आप सक्षम नहीं होंगे इसे अपने कोड में आगे बढ़ाएं। उदाहरण के आंतरिक स्थिति में इस विधि को किए गए सभी परिवर्तन खो जाएंगे।

A a1 = new A(); a1.doThis(); आप एक वस्तु का उदाहरण संरक्षित करने के लिए अपने राज्य विधि doThis() द्वारा बनाई गई करने के लिए बनाया गया है और संभावित परिवर्तनों (चर a1 में) जा रहे हैं के मामले में

। फिर आप इस ऑब्जेक्ट के साथ काम करना जारी रख सकेंगे।