अन्य केस ब्लॉक में उपलब्ध केस ब्लॉक में चर परिभाषित क्यों हैं?

Question

संभव डुप्लिकेट:
Why are variables not local in case statements?

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

{ 
    int anothervar = 4; 
} 
{ 
    System.out.println(anothervar); 
} 

लेकिन जैसे एक case ब्लॉक स्कोप अलग पैदा नहीं करता यह लग रहा है।

switch (mode) { 
    case ONE: 
     dosomething(); 
     return; 
    case TWO: 
     int[] someints = new int[] { 2, 3, 5, 7 }; 
     SomeObject obj = new SomeObject(); 
     return; 
    case THREE: 
     someints = new int[] { 1, 4, 6, 8, 9 }; 
     obj = new SomeObject(); 
     return; 
} 

मैं क्यों someintscase THREE 'ब्लॉक' के अंदर घोषित करने के लिए नहीं है?
मान लीजिए mode = THREE, तो परिवर्तनीय someints की घोषणा कभी नहीं पहुंची है, क्योंकि case TWO, जहां someints घोषित किया गया है, छोड़ा गया है। या है ना? यह आंतरिक रूप से कैसे काम करता है?

(Why are variables not local in case statements? में चुना जवाब कहा गया है कि एक स्विच बयान आंतरिक jump आदेशों का एक सेट है, लेकिन अभी भी है कि स्पष्ट नहीं होता जहां चर someints घोषित किया जाता है।)

Answer 1

एक स्थानीय चर का दायरा, एक ब्लॉक के अंदर है Names documentation:

एक ब्लॉक में एक स्थानीय चर घोषणा की गुंजाइश (§14.4.2) ब्लॉक के बाकी है, जिसमें घोषणापत्र प्रकट होता है, इसके के साथ प्रारंभिक प्रारंभकर्ता (§14.4) और पर स्थानीय परिवर्तनीय घोषणा विवरण में आगे के घोषणाकर्ताओं सहित।

एक ब्लॉक, के रूप में Blocks and Statements documentation के साथ-साथ लिखा ब्रेसिज़ संलग्न की है, परिभाषित किया गया है:

एक ब्लॉक बयान, स्थानीय वर्ग घोषणाओं और ब्रेसिज़ के भीतर स्थानीय चर घोषणा बयान के एक दृश्य है।

Answer 2

सब कुछ { } अंदर ही में है गुंजाइश। यदि आप उदाहरण के लिए TWO के मामले में return; निकालते हैं, तो आप तीन के मामले में चर का उपयोग कर सकते हैं, बशर्ते इसे प्रारंभ किया गया हो।

Answer 3

यही कारण है कि आप कभी कभी के साथ कोड देखें:

case 0: { 
    // Stuff 
} 

केवल {} ब्लॉक delimitates। में विनिर्दिष्ट

Answer 4

घोषणा का एक दायरा { ... } द्वारा चिह्नित किया गया है और आप एक मामले में एक मामले से गिर सकते हैं। मैं स्वीकार करता हूं कि यह एक छेद है।

case 1: { int x; ... } 

Answer 5

अन्य answerers के अतिरिक्त (के रूप में वे देखा, के बीच {} गुंजाइश एक ही है: मैं जावा एक के एक पुराने संस्करण में विश्वास करते हैं case स्तर पर घोषित करने के लिए अनुमति दी है और नहीं कर रहा था अतिरिक्त ब्रेसिज़ जोड़ने के लिए किया था यहां) मैं नोटिस करना चाहता हूं, कि इस तरह की प्रथा: एक मामले में एक चर की घोषणा करना और दूसरे में इसका उपयोग करना, गंदे है। बाद में आप कुछ मामले को हटाना या बदलना चाहते हैं। और अगर यह घोषणा के साथ होगा, तो आपको एक और मामला बदलना होगा। इससे त्रुटियां हो सकती हैं।

अच्छी तरह से सोचें - क्यों आपके परिवर्तनीय कुछ मामलों में होना चाहिए? क्या यह वास्तव में एक ही चीज़ या दो अलग है?

यदि यह वही है: डिफ़ॉल्ट मामले में सामान्य चर को बेहतर घोषित करें और इसे पहले के रूप में रखें।

switch (mode) { 
    default: 
     int[] someints; 
     return; 
    case ONE: 
     dosomething(); 
     return; 
    case TWO: 
     someints = new int[] { 2, 3, 5, 7 }; 
     SomeObject obj = new SomeObject(); 
     return; 
    case THREE: 
     someints = new int[] { 1, 4, 6, 8, 9 }; 
     obj = new SomeObject(); 
     return; 
} 

या उन्हें स्विच ब्लॉक से बाहर घोषित करें (यह बदतर है)। या इसे कहीं भी रखें जहां आप स्थिरांक परिभाषित करते हैं।

यदि वे वास्तव में अलग-अलग चर हैं (केवल कुछ ही तरीके से समान हो सकते हैं): प्रत्येक मामले में एक अलग चर परिभाषित करता है।

बीटीडब्ल्यू: यह वास्तव में एक अच्छा सवाल है!