java जावा और क्लोजर में अनाम कक्षाओं के बीच क्या अंतर है?




closures terminology (3)

ऐसा लगता है कि अनाम वर्ग बंद होने की बुनियादी कार्यक्षमता प्रदान करता है, क्या यह सच है?


जहां तक ​​वे दोनों "निजी" स्कूपिंग को बहुत सीमित अर्थों में प्रभावित करते हैं, हां। हालाँकि, वहाँ बहुत सारे मतभेद हैं कि जवाब नहीं भी हो सकता है।

चूंकि जावा में कोड के ब्लॉक को सही R-मान के रूप में संभालने की क्षमता का अभाव है, इसलिए आंतरिक वर्ग कोड के ब्लॉक को पारित नहीं कर सकते हैं जैसा कि आमतौर पर निरंतरता में किया जाता है। इसलिए एक निरंतरता तकनीक के रूप में बंद पूरी तरह से गायब है।

जबकि एक वर्ग के जीवन का कचरा एकत्र किया जाता है, जो कि भीतर के वर्गों को धारण करने वाले लोगों द्वारा बढ़ाया जाता है (इसी तरह बंद होने के दौरान इसे जीवित रखने के लिए चर को बंद करते हुए), जावा की बाइंडिंग के माध्यम से नाम बदलने की क्षमता मौजूदा जावा सिंटैक्स के अनुपालन तक सीमित है ।

और जावा के थ्रेड कंटेम्पशन मॉडल का उपयोग करके थ्रेड्स को एक दूसरे के डेटा पर ठीक से स्टैम्प न करने की अनुमति देने के लिए, आंतरिक कक्षाओं को डेटा तक पहुंच के साथ प्रतिबंधित किया जाता है जो कि परेशान नहीं है, उर्फ ​​अंतिम लोकल।

यह पूरी तरह से अन्य आंतरिक वर्गों (उर्फ स्टेटिक इनर क्लासेस) को नजरअंदाज कर देता है, जो थोड़ा अलग है। दूसरे शब्दों में, यह कुछ वस्तुओं को छूता है, जो बंद हो सकती हैं, लेकिन न्यूनतम आवश्यकताओं से कम हो जाती हैं, जिन्हें ज्यादातर लोग आवश्यक रूप से बंद करने वाला कहेंगे।


IMHO, वे एक समान उद्देश्य की सेवा करते हैं, हालांकि एक बंद का उद्देश्य अधिक संक्षिप्त होना है और संभावित रूप से अधिक कार्यक्षमता प्रदान करना है।

कहते हैं कि आप अनाम वर्ग का उपयोग करके स्थानीय चर का उपयोग करना चाहते हैं।

final int[] i = { 0 };
final double[] d = { 0.0 };

Runnable run = new Runnable() { 
    public void run() {
        d[0] = i[0] * 1.5;
    }
};
executor.submit(run);

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

int i = 0;
double d = 0.0;

Runnable run = { => d = i * 1.5; };
executor.submit(run);

या और भी

executor.submit({ => d = i * 1.5; });

या यदि बंद समर्थन कोड ब्लॉक करता है।

executor.submit() {
    d = i * 1.5; 
}

लगभग कोई अंतर नहीं है। वास्तव में बंद और वस्तुओं के बारे में एक पुरानी कहावत है। क्लोजर गरीब आदमी की वस्तु है, और वस्तुएं गरीब आदमी की बंदी हैं। वे जो कर सकते हैं उसके संदर्भ में दोनों समान रूप से शक्तिशाली हैं। हम केवल अभिव्यक्ति पर बहस कर रहे हैं।

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

http://madbean.com/2003/mb2003-49/

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

public Object someFunction() {
   int someValue = 0;

   SomeAnonymousClass implementation = new SomeAnonymousClass() {
       public boolean callback() {
           someValue++;
       }
   }
   implementation.callback();
   return someValue;
}

के लिए फिर से लिखा जाएगा:

 public Object someFunction() {
   SomeAnonymousClass implementation = new SomeAnonymousClass() {
       public int someValue = 0;

       public boolean callback() {
           someValue++;
       }
   }
   implementation.callback();

   // all references to someValue could be rewritten to 
   // use this instance variable instead.
   return implementation.someValue;
}

मुझे लगता है कि लोगों को बेनामी आंतरिक वर्गों के बारे में शिकायत करने का कारण स्थिर टाइपिंग बनाम डायनामिक टाइपिंग से अधिक है। जावा में हमें अनाम वर्ग के कार्यान्वयनकर्ता और अनाम वर्ग को स्वीकार करने वाले कोड के इंटरफ़ेस पर सहमति व्यक्त करनी होगी। हमें ऐसा करना होगा ताकि हम सब कुछ संकलन समय पर जांच सकें। यदि हमारे पास प्रथम श्रेणी के कार्य हैं, तो जावा को एक विधि के मापदंडों की घोषणा करने के लिए एक वाक्यविन्यास को परिभाषित करने और डेटा सुरक्षा के लिए एक टाइप टाइप भाषा के रूप में टाइप करने के लिए टाइप सुरक्षा के लिए परिभाषित करने की आवश्यकता होगी। यह लगभग एक इंटरफ़ेस को परिभाषित करने जितना ही जटिल होगा। (एक इंटरफ़ेस कई विधियों को परिभाषित कर सकता है, पहली कक्षा के तरीकों को घोषित करने के लिए एक वाक्यविन्यास केवल एक विधि के लिए होगा)। आप इसे शॉर्ट फॉर्म इंटरफेस सिंटैक्स के रूप में सोच सकते हैं। हुड के तहत कंपाइलर एक संक्षिप्त समय में संक्षिप्त रूप संकेतन का इंटरफ़ेस में अनुवाद कर सकता है।

बहुत सी चीजें हैं जो भाषा या प्रमुख सर्जरी को खोले बिना बेनामी कक्षा के अनुभव को बेहतर बनाने के लिए जावा में की जा सकती हैं।





anonymous-class