जावा में स्विच स्टेटमेंट का दायरा क्यों सीमित नहीं है?

Question

जावा में, एक ब्लॉक ब्लॉक के विपरीत एक स्विच ब्लॉक तक सीमित एक चर का दायरा क्यों है। उदाहरण के लिए,

// Scope limited to a switch block 
switch (number) { 
case 1: 
    String result = "..."; 
    break; 
case 2: 
    result = "..."; 
    break; 

उपरोक्त उदाहरण में, परिणाम केवल एक बार घोषित करने की आवश्यकता है। यदि आप इसे दो बार घोषित करते हैं तो आपको Duplicate local variable संदेश प्राप्त होता है।

मेरा प्रश्न है: प्रोग्राम को पता है कि result अगर number = 2 घोषित किया गया है? (यह case 1 में आते हैं नहीं और चर की घोषणा नहीं करेगा ... या होगा यह?)

संपादित करें:

मैं हर किसी को भ्रमित किया जा सकता है। मैं समझता हूं कि मैं एक चर के दायरे को कैसे सीमित कर सकता हूं लेकिन मेरा प्रश्न है: जावा कैसे जानता है कि परिणाम घोषित किया गया है यदि यह मामले में नहीं आता है?

Answer 1

संपादित करें: जावा लेक्सिकल स्कॉइंग (स्थिर स्कोपिंग भी कहा जाता है) का उपयोग करता है, इसलिए चर के समय के दौरान चर के दायरे को निर्धारित किया जाता है, और वास्तविक मूल्यांकन के साथ कुछ लेना देना नहीं है।

जावा ब्लॉक स्कॉप्ड है, इसलिए इसका दायरा ऊपर दिए गए उदाहरण में {} का सम्मान करेगा।

JLS 6.3 देखें:

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

Answer 2

जावा ब्लॉक स्कोपिंग का उपयोग करता है, चुनिंदा मामलों ब्लॉक नहीं हैं (वे लेबल की तरह अधिक हैं)। यह हालांकि काम करेगा:

// Scope limited to a switch block 
switch (number) { 
case 1:{ 
    String result = "..."; 
    break; 
} 
case 2:{ 
    String result = "..."; 
    break; 
} 

Answer 3

आप इस तरह कर्ली कोष्ठक जोड़कर मामले ब्लॉकों के लिए दायरा सीमित कर सकते हैं? जवाब को समझने के लिए आपको यह जानने की जरूरत है कि कंपेलर कैसे काम करते हैं। प्रत्येक स्विच स्टेटमेंट के अंत में कई "गोटो" कथन के साथ एक बड़े ब्लॉक के रूप में स्विच के बारे में सोचें।

मैं कैसे जावा उतारना स्विच बयान लेकिन एक आसान और सरल तरीके से करना सुनिश्चित करें कि यह इस (छद्म बाइट-कोड) है नहीं कर रहा हूँ:

if (number == 1) goto label1; 
    if (number == 2) goto label2; 
    goto labelEnd; 
label1: 
    String result = "..."; 
    goto labelEnd; 
label2: 
    result = "..."; 
    goto labelEnd; 
labelEnd: 
    <some code> 

Answer 4

आपका क्या मतलब है कैसे:

switch (key) { 
case 1: { 
    String result = "1"; 
    return result ; 
    } 
case 2: { 
    String result = "2"; 
    return result ; 
    } 
} 

Answer 5

दादा भाषा फोरट्रान में, वहाँ है एक गणना गोटो बयान

 GOTO expr 
     ... 
    1 ... 
     ... 
    2 ... 
     ... 

expr के मूल्य पर आधारित, कोड 1, 2 आदि

सी (और जावा के) switch बयान basical है कूदता छिपाने में एक गणना गोटो ly। हमारे पास कुछ लेबल के साथ कोड का निरंतर टुकड़ा है, और हम लेबल में से एक पर कूदते हैं। यदि break नहीं है तो हम शेष ब्लॉक निष्पादित करेंगे।

यह निम्न स्तर नियंत्रण प्रणाली आज के प्रोग्रामर के अंतर्ज्ञान के विपरीत है; हम सोचेंगे कि स्विच स्टेटमेंट एक खंड का चयन करता है और उस खंड को निष्पादित करता है, जो if-elseif-elseif-...-else कथन की तरह है।

जावा विरासत में सी के स्विच सेमेन्टिक्स विरासत में मिला क्योंकि वे सी से बहुत विचलित नहीं होना चाहते थे। नई भाषा गलती जारी रखने की संभावना नहीं है।

Answer 6

कारण एक चर गुंजाइश के रूप में एक मामला ब्लॉक करने का विरोध एक स्विच ब्लॉक तक ही सीमित है जावा गिरावट के लिए के माध्यम से एक मामले ब्लॉक से अगले यानी

switch (number) { 
case 1: 
    .... some code ... 
case 2: 
    .... some more code ... 

को इस मामले के मामले में यदि संख्या 1 है की अनुमति देता है , दोनों मामले 1 & केस 2 निष्पादित किए गए हैं। ब्रेक चुनने के गेटो एंड की तरह काम करता है, यह कभी भी गुंजाइश खत्म नहीं करता है। परिवर्तनीय दायरा पर स्तर पर होना चाहिए।

दूसरों के रूप में कहा है, गुंजाइश अर्थात

switch (number) { 
case 1:{ 
    String result = "..."; 
    break; 
} 
case 2:{ 
    String result = "..."; 
    break; 
} 

Answer 7

प्रतिबंधित करने के लिए क्योंकि वहाँ एक 'मामले ब्लॉक' नहीं है एक ब्लॉक का उपयोग करें।

स्विच स्टेटमेंट के अंदर सबकुछ एक ही ब्लॉक में है। आप एक ही वैरिएबल को एक ही ब्लॉक में दो बार घोषित नहीं कर सकते हैं।

यदि आप 'केस ब्लॉक' चाहते हैं तो आपको { और } स्वयं लिखना होगा।