दिलचस्प पोस्ट
आप एक एनएएम को धाराप्रवाह NHibernate के साथ एक इंट मान के रूप में कैसे मैप करते हैं? .NET अनुप्रयोगों के मेमोरी उपयोग को कम करना? छवि को वेबसाइट से स्थानीय फ़ाइल में खींचने के लिए httpwebrequest का उपयोग कैसे करें जावा इंटरफेस में वैकल्पिक तरीके nginx प्रॉक्सी पास नोड, एसएसएल? संभवतः पीछे की तरफ से पुनरावृति करना संभव है? एंड्रॉइड एपीके के पैकेज नाम को पढ़ें कैसे ढाल के साथ सूत्रों का जार बनाने के लिए ऑफ़लाइन होने पर OKHttp के साथ रेट्रोफ़िट कैश डेटा का उपयोग कर सकते हैं जिन मामलों में सीडीएन अवरुद्ध / अनुपलब्ध हैं वहां स्थानीय स्क्रिप्ट फाइलों को फॉलबैक के रूप में कैसे लोड करें? Django 1.9 बहिष्कार चेतावनी app_label प्रश्न चिह्नों द्वारा अमान्य UTF-8 वर्णों को प्रतिस्थापित करना, mbstring.substitute_character को नजरअंदाज किया जाता है एकाधिक ईवेंट श्रोताओं को एक तत्व में जोड़ना क्लास ऑब्जेक्ट (java.lang.Class) क्या है? एक टेक्स्ट फ़ील्ड का उपयोग करके "Y का पेज X" दिखाएं

जावा में बेनामी कोड ब्लॉक

क्या जावा में अनाम कोड ब्लॉक के कोई व्यावहारिक उपयोग हैं?

public static void main(String[] args) { // in { // out } } 

कृपया ध्यान दें कि यह नामित ब्लॉक के बारे में नहीं है, अर्थात

 name: { if ( /* something */ ) break name; } 

Solutions Collecting From Web of "जावा में बेनामी कोड ब्लॉक"

वे चर गुंजाइश को प्रतिबंधित करते हैं।

 public void foo() { { int i = 10; } System.out.println(i); // Won't compile. } 

व्यवहार में, यद्यपि, यदि आप ऐसे कोड ब्लॉक का प्रयोग कर पाते हैं जो संभवत: एक संकेत है जो आप एक विधि से बाहर ब्लॉक करना चाहते हैं।

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

 JPanel mainPanel = new JPanel(new BorderLayout()); { JLabel centerLabel = new JLabel(); centerLabel.setText("Hello World"); mainPanel.add(centerLabel, BorderLayout.CENTER); } { JPanel southPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 0,0)); { JLabel label1 = new JLabel(); label1.setText("Hello"); southPanel.add(label1); } { JLabel label2 = new JLabel(); label2.setText("World"); southPanel.add(label2); } mainPanel.add(southPanel, BorderLayout.SOUTH); } 

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

एक विधि में प्रत्येक घटक तात्कालिकता को फैक्टरिंग के साथ मेरी समस्या यह है कि

  1. इस पद्धति का उपयोग केवल एक व्यापक दर्शक तक पहुंचने के बाद किया जाएगा, भले ही यह एक निजी उदाहरण विधि है
  2. गहरा और जटिल घटक पेड़ की कल्पना करना, पढ़ना कठिन होता है, आपको उस कोड को खोजने के लिए नीचे ड्रिल करना पड़ता है, जिसकी आपको दिलचस्पी है, और फिर दृश्यमान संदर्भ ढूढ़ें।

इस घुमाव के उदाहरण में, मुझे लगता है कि जब जटिलता वास्तव में प्रबंधनक्षमता से आगे बढ़ती है, तो यह इंगित करता है कि यह समय के पेड़ की एक शाखा को छोटे तरीकों के बजाय एक नए वर्ग में फैलाने का है।

स्थानीय रूप से संभव के रूप में छोटे के रूप में संभव के रूप में यह आमतौर पर सबसे अच्छा है । अनाम कोड ब्लॉक इस के साथ मदद कर सकता है।

मुझे यह switch स्टेटमेंट के साथ विशेष रूप से उपयोगी लगता है। निम्न उदाहरण पर विचार करें, अनाम कोड ब्लॉक के बिना:

 public String manipulate(Mode mode) { switch(mode) { case FOO: String result = foo(); tweak(result); return result; case BAR: String result = bar(); // Compiler error twiddle(result); return result; case BAZ: String rsult = bar(); // Whoops, typo! twang(result); // No compiler error return result; } } 

और अज्ञात कोड ब्लॉक के साथ:

 public String manipulate(Mode mode) { switch(mode) { case FOO: { String result = foo(); tweak(result); return result; } case BAR: { String result = bar(); // No compiler error twiddle(result); return result; } case BAZ: { String rsult = bar(); // Whoops, typo! twang(result); // Compiler error return result; } } } 

मुझे दूसरा संस्करण क्लीनर और पढ़ने में आसान माना जाता है और, यह उन चर के दायरे को कम कर देता है, जिनके मामले में स्विच के भीतर घोषित किया गया था, जिस पर उन्हें घोषित किया गया था, जो मेरे अनुभव में है कि 99%

हालांकि चेतावनी दीजिए, यह मामला गिरने के व्यवहार के लिए नहीं बदलेगा – आपको अब भी इसे रोकने के लिए एक break या return शामिल करना याद रखना होगा!

मुझे लगता है कि आप और / या अन्य उत्तर दो अलग वाक्यविन्यास निर्माणों को भ्रमित कर रहे हैं; अर्थात् इंस्टेंस इनिशियलाइज़र एंड ब्लॉक्स (और वैसे, एक "नामित ब्लॉक" वास्तव में एक लेबल वाला वक्तव्य है, जहां विवरण एक ब्लॉक होता है।)

एक उदाहरण प्रारंभकर्ता का उपयोग किसी वर्ग के सदस्य के वाक्य-रचनात्मक स्तर पर किया जाता है; जैसे

 public class Test { final int foo; { // Some complicated initialization sequence; eg int tmp; if (...) { ... tmp = ... } else { ... tmp = ... } foo = tmp; } } 

आरंभिक निर्माण का सबसे अधिक उपयोग @ डोफा के उदाहरण के अनुसार अज्ञात वर्गों के लिए किया जाता है। एक अन्य उपयोग-मामले 'अंतिम' विशेषताओं के जटिल प्रारंभ करने के लिए है; उदाहरण के ऊपर उदाहरण देखें (हालांकि, यह एक नियमित कन्स्ट्रक्टर का उपयोग करने के लिए ऐसा करने के लिए अधिक सामान्य है। ऊपर दिए गए पैटर्न को स्टेटिक इनाइलाइज़र के साथ आमतौर पर उपयोग किया जाता है।)

अन्य निर्माण एक साधारण ब्लॉक है और एक कोड ब्लॉक में दिखाई देता है जैसे कि विधि; जैसे

 public void test() { int i = 1; { int j = 2; ... } { int j = 3; ... } } 

बयानों का एक क्रम समूह करने के लिए ब्लाकों को सबसे अधिक सामान्यतः नियंत्रण स्टेटमेंट के भाग के रूप में उपयोग किया जाता है लेकिन जब आप उनका उपयोग करते हैं, तो वे (बस) आपको घोषणाओं की दृश्यता को प्रतिबंधित करने की अनुमति देते हैं; जैसे ऊपर j

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

  switch (op) { case OP1: { int tmp = ...; // do something break; } case OP2: { int tmp = ...; // do something else break; } ... }; 

आप अनाम आंतरिक कक्षाओं के लिए कन्स्ट्रक्टर के रूप में इसका उपयोग कर सकते हैं।

इस कदर:

वैकल्पिक पाठ http://img113.imageshack.us/img113/888/capturadepantalla200910.png

इस तरह से आप अपने ऑब्जेक्ट को इनिशियलाइज कर सकते हैं, चूंकि ऑब्जेक्ट कंस्ट्रक्शन के दौरान नि: शुल्क ब्लॉक निष्पादित होता है।

यह अनाम आंतरिक कक्षाओं तक सीमित नहीं है, यह नियमित कक्षाओं पर भी लागू होता है

 public class SomeClass { public List data;{ data = new ArrayList(); data.add(1); data.add(1); data.add(1); } } 

गुमनाम ब्लॉकों वेरिएबल के दायरे को सीमित करने के साथ-साथ डबल ब्रेस आरंभीकरण के लिए उपयोगी हैं। की तुलना करें:

 Set<String> validCodes = new HashSet<String>(); validCodes.add("XZ13s"); validCodes.add("AB21/X"); validCodes.add("YYLEX"); validCodes.add("AR2D"); 

साथ में:

 Set<String> validCodes = new HashSet<String>() {{ add("XZ13s"); add("AB21/X"); add("YYLEX"); add("AR5E"); }}); 

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

 public void test(final int x) { final ClassA a; final ClassB b; { final ClassC parmC = getC(x); a = parmC.getA(); b = parmC.getB(); } //... a and b are initialized } 

सामान्य तौर पर ब्लॉक को एक विधि में स्थानांतरित करने के लिए बेहतर होता है, लेकिन यह सिंटैक्स एक बार मामलों के लिए अच्छा हो सकता है जब कई चर को वापस करने की आवश्यकता होती है और आप रैपर क्लास नहीं बनाना चाहते हैं।