जावा में एक गोटो स्टेटमेंट के लिए वैकल्पिक

Question 1

जावा में गोटो कीवर्ड के लिए एक वैकल्पिक कार्य क्या है ?

चूंकि जावा में गोटो नहीं है।

Question 2

आप एक लेबल BREAK कथन का उपयोग कर सकते हैं :

search:
    for (i = 0; i < arrayOfInts.length; i++) {
        for (j = 0; j < arrayOfInts[i].length; j++) {
            if (arrayOfInts[i][j] == searchfor) {
                foundIt = true;
                break search;
            }
        }
    }

हालाँकि, ठीक से डिज़ाइन किए गए कोड में, आपको GOTO कार्यक्षमता की आवश्यकता नहीं होनी चाहिए।

Question 3

gotoजावा में अवधारणा के बराबर कोई प्रत्यक्ष नहीं है । कुछ निर्माण हैं जो आपको क्लासिक के साथ कुछ चीजें करने की अनुमति देते हैं goto।

breakऔर continueबयान आप एक पाश या स्विच बयान में एक ब्लॉक से बाहर कूद करने के लिए अनुमति देते हैं।
एक लेबल किया गया कथन और break <label>आपको दिए गए तरीके (या इनिशियलाइज़र ब्लॉक) के भीतर किसी भी स्तर पर एक मनमाना यौगिक विवरण से बाहर निकलने की अनुमति देता है।
यदि आप एक लूप स्टेटमेंट लेबल करते हैं, तो आप continue <label>आंतरिक लूप से बाहरी लूप के अगले पुनरावृत्ति के साथ जारी रख सकते हैं ।
अपवाद को फेंकना और पकड़ना आपको एक विधि कॉल के कई स्तरों से (प्रभावी रूप से) कूदने की अनुमति देता है। (हालांकि, अपवाद अपेक्षाकृत महंगे हैं और "साधारण" नियंत्रण प्रवाह ¹ करने के लिए एक बुरा तरीका माना जाता है ।)
और हां, है return।

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

^{1- अपवादों का सबसे महंगा हिस्सा अपवाद वस्तु और उसके स्टैकट्रेस का वास्तविक निर्माण है। यदि आपको वास्तव में, "सामान्य" प्रवाह नियंत्रण के लिए अपवाद हैंडलिंग का उपयोग करने की आवश्यकता है, तो आप अपवाद ऑब्जेक्ट का प्रचार / पुन: उपयोग कर सकते हैं, या fillInStackTrace()विधि को ओवरराइड करने वाले कस्टम अपवाद वर्ग बना सकते हैं । नकारात्मक पक्ष यह है कि अपवाद के printStackTrace()तरीके आपको उपयोगी जानकारी नहीं देंगे ... क्या आपको कभी उन्हें कॉल करने की आवश्यकता है।}

^{2 - स्पेगेटी कोड सिंड्रोम ने संरचित प्रोग्रामिंग दृष्टिकोण को जन्म दिया , जहां आप उपलब्ध भाषा निर्माण के अपने उपयोग में सीमित हैं। इसे BASIC , Fortran और COBOL पर लागू किया जा सकता है , लेकिन इसके लिए देखभाल और अनुशासन आवश्यक है। gotoपूरी तरह से छुटकारा पाना एक व्यावहारिक रूप से बेहतर समाधान था। यदि आप इसे किसी भाषा में रखते हैं, तो हमेशा कुछ विदूषक होता है जो इसका दुरुपयोग करेगा।}

Question 4

बस मज़े के लिए, यहाँ जावा में एक GOTO कार्यान्वयन है।

उदाहरण:

   1 public class GotoDemo {
   2     public static void main(String[] args) {
   3         int i = 3;
   4         System.out.println(i);
   5         i = i - 1;
   6         if (i >= 0) {
   7             GotoFactory.getSharedInstance().getGoto().go(4);
   8         }
   9         
  10         try {
  11             System.out.print("Hell");
  12             if (Math.random() > 0) throw new Exception();            
  13             System.out.println("World!");
  14         } catch (Exception e) {
  15             System.out.print("o ");
  16             GotoFactory.getSharedInstance().getGoto().go(13);
  17         }
  18     }
  19 }

इसे चलाना:

$ java -cp bin:asm-3.1.jar GotoClassLoader GotoDemo           
   3
   2
   1
   0
   Hello World!

क्या मुझे "इसका उपयोग नहीं करना है?"

Question 5

हालांकि कुछ टिप्पणीकारों और डाउनवोटर्स का तर्क है कि यह गोटो नहीं है , नीचे दिए गए जावा स्टेटमेंट से उत्पन्न बायटेकोड वास्तव में बताता है कि ये कथन वास्तव में गोटो शब्दार्थ व्यक्त करते हैं ।

विशेष रूप से, do {...} while(true);लूप की स्थिति का मूल्यांकन नहीं करने के लिए दूसरे उदाहरण में लूप को जावा कंपाइलरों द्वारा अनुकूलित किया जाता है।

कूदते हुए आगे

label: {
  // do stuff
  if (check) break label;
  // do more stuff
}

बायोटेक में:

2  iload_1 [check]
3  ifeq 6          // Jumping forward
6  ..

पीछे की ओर कूदना

label: do {
  // do stuff
  if (check) continue label;
  // do more stuff
  break label;
} while(true);

बायोटेक में:

 2  iload_1 [check]
 3  ifeq 9
 6  goto 2          // Jumping backward
 9  ..

Question 6

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

आपको लेबल को तोड़ने के लिए ब्लॉक के दायरे में रहना होगा:

namedBlock: {
  if (j==2) {
    // this will take you to the label above
    break namedBlock;
  }
}

मैं आपको इस बात पर व्याख्यान नहीं दूंगा कि आपको गोटो से क्यों बचना चाहिए - मुझे लगता है कि आप पहले से ही इसका जवाब जानते हैं।

Question 7

public class TestLabel {

    enum Label{LABEL1, LABEL2, LABEL3, LABEL4}

    /**
     * @param args
     */
    public static void main(String[] args) {

        Label label = Label.LABEL1;

        while(true) {
            switch(label){
                case LABEL1:
                    print(label);

                case LABEL2:
                    print(label);
                    label = Label.LABEL4;
                    continue;

                case LABEL3:
                    print(label);
                    label = Label.LABEL1;
                    break;

                case LABEL4:
                    print(label);
                    label = Label.LABEL3;
                    continue;
            }
            break;
        }
    }

    public final static void print(Label label){
        System.out.println(label);
    }

Question 8

स्टीफन लिखते हैं:

दो निर्माण हैं जो आपको क्लासिक गोटो के साथ कुछ चीजें करने की अनुमति देते हैं।

एक और...

मैट वोल्फ लिखते हैं:

लोग हमेशा गोटो का उपयोग न करने के बारे में बात करते हैं, लेकिन मुझे लगता है कि वास्तव में एक अच्छा विश्व उपयोग का मामला है जो बहुत अच्छी तरह से जाना जाता है और उपयोग किया जाता है .. यही है, एक फ़ंक्शन से लौटने से पहले कुछ कोड निष्पादित करना सुनिश्चित करता है .. आमतौर पर इसका विमोचन ताले या क्या नहीं, लेकिन मेरे मामले में मैं वापसी से ठीक पहले एक ब्रेक पर कूदना चाहूंगा ताकि मैं अनिवार्य सफाई कर सकूं।

try {
    // do stuff
    return result;  // or break, etc.
}
finally {
    // clean up before actually returning, even though the order looks wrong.
}

http://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html

अंततः ब्लॉक हमेशा निष्पादित होता है जब कोशिश ब्लॉक से बाहर निकलता है। यह सुनिश्चित करता है कि अंत में ब्लॉक निष्पादित किया जाता है भले ही एक अप्रत्याशित अपवाद हो। लेकिन अंत में अपवाद अपवाद से अधिक के लिए उपयोगी है - यह प्रोग्रामर को गलती से वापसी, जारी रखने या तोड़ने के द्वारा बाईपास किए गए सफाई कोड से बचने की अनुमति देता है। अंत में ब्लॉक में सफाई कोड डालना हमेशा एक अच्छा अभ्यास होता है, तब भी जब कोई अपवाद प्रत्याशित न हो।

अंत में जुड़े हुए मूर्खतापूर्ण साक्षात्कार का प्रश्न है: यदि आप एक कोशिश {} ब्लॉक से लौटते हैं, लेकिन आपके अंत में एक वापसी {} भी है, तो कौन सा मान लौटाया जाता है?

Question 9

सबसे आसान है:

int label = 0;
loop:while(true) {
    switch(state) {
        case 0:
            // Some code
            state = 5;
            break;

        case 2:
            // Some code
            state = 4;
            break;
        ...
        default:
            break loop;
    }
}

Question 10

नीचे दिए गए कोड को आज़माएं। इससे मेरा काम बनता है।

for (int iTaksa = 1; iTaksa <=8; iTaksa++) { // 'Count 8 Loop is  8 Taksa

    strTaksaStringStar[iCountTaksa] = strTaksaStringCount[iTaksa];

    LabelEndTaksa_Exit : {
        if (iCountTaksa == 1) { //If count is 6 then next it's 2
            iCountTaksa = 2;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 2) { //If count is 2 then next it's 3
            iCountTaksa = 3;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 3) { //If count is 3 then next it's 4
            iCountTaksa = 4;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 4) { //If count is 4 then next it's 7
            iCountTaksa = 7;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 7) { //If count is 7 then next it's 5
            iCountTaksa = 5;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 5) { //If count is 5 then next it's 8
            iCountTaksa = 8;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 8) { //If count is 8 then next it's 6
            iCountTaksa = 6;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 6) { //If count is 6 then loop 1  as 1 2 3 4 7 5 8 6  --> 1
            iCountTaksa = 1;
            break  LabelEndTaksa_Exit;
        }
    }   //LabelEndTaksa_Exit : {

} // "for (int iTaksa = 1; iTaksa <=8; iTaksa++) {"

Question 11

गोटो के विकल्प के रूप में एक लेबल ब्रेक का उपयोग करें।

Question 12

जावा में नहीं है goto, क्योंकि यह कोड को असंरचित और पढ़ने में अस्पष्ट बनाता है । हालांकि, अगर आप उपयोग कर सकते हैं breakऔर continueके रूप में सभ्य के रूप गोटो अपनी समस्याओं के बिना।

ब्रेक का उपयोग करके आगे कूदना -

ahead: {
    System.out.println("Before break");
    break ahead;
    System.out.println("After Break"); // This won't execute
}
// After a line break ahead, the code flow starts from here, after the ahead block
System.out.println("After ahead");

आउटपुट :

Before Break
After ahead

जंप बैकवर्ड का उपयोग जारी है

before: {
    System.out.println("Continue");
    continue before;
}

इसके परिणामस्वरूप एक अनंत लूप होगा क्योंकि हर बार लाइन continue beforeनिष्पादित होने के बाद, कोड प्रवाह फिर से शुरू हो जाएगाbefore ।