Java Language
बुनियादी नियंत्रण संरचनाएं

टिप्पणियों

// valid, but discouraged
Scanner scan = new Scanner(System.in);
int val = scan.nextInt();
if(val % 2 == 0)
    System.out.println("Val was even!");


// invalid; will not compile
// note the misleading indentation here
for(int i = 0; i < 10; i++)
    System.out.println(i);
    System.out.println("i is currently: " + i);

इफ / एल्स इफ / एल्स कंट्रोल

if (i < 2) {
  System.out.println("i is less than 2");
} else if (i > 2) {
  System.out.println("i is more than 2");
} else {
  System.out.println("i is not less than 2, and not more than 2");
}

if ब्लॉक चलेगा जब i 1 या उससे कम है।

else if स्थिति को केवल तभी जांचा जाता है यदि इससे पहले की सभी स्थितियां ( else if निर्माण करता है else if पूर्व में, और if निर्माण करता है if माता-पिता) को false परीक्षण किया गया false । इस उदाहरण में, अगर i केवल 2 से अधिक या बराबर है, else if शर्त केवल तभी जाँच की जाएगी।

यदि इसका परिणाम true , तो इसका ब्लॉक चलाया जाता है, और else if इसके बाद else निर्माण करता है तो उसे छोड़ दिया जाएगा।

में से कोई भी तो if और else if शर्तों के परीक्षण किया गया है true , else अंत में ब्लॉक चलाया जाएगा।

लूप्स के लिए

for (int i = 0; i < 100; i++) {
    System.out.println(i);
}

के तीन घटक for लूप (द्वारा अलग ; ) अलग-अलग घोषणा / प्रारंभ कर रहे हैं (यहाँ int i = 0 ), हालत (यहाँ i < 100 ), और वेतन वृद्धि बयान (यहाँ i++ )। चर घोषणा एक बार की जाती है जैसे कि पहले भाग में { अंदर रखी गई हो। फिर स्थिति की जांच की जाती है, अगर यह true है कि लूप का शरीर निष्पादित करेगा, अगर यह false तो लूप बंद हो जाएगा। यह मानते हुए कि लूप जारी है, शरीर निष्पादित करेगा और अंत में } तक पहुंचने पर वेतन वृद्धि की स्थिति को फिर से जाँचने से पहले निष्पादित करेगा।

घुंघराले ब्रेसिज़ वैकल्पिक हैं (आप अर्धविराम के साथ एक पंक्ति कर सकते हैं) यदि लूप में सिर्फ एक बयान होता है। लेकिन, गलतफहमी और बग से बचने के लिए हमेशा ब्रेसिज़ का उपयोग करने की सिफारिश की जाती है।

for पाश घटकों वैकल्पिक हैं। यदि आपके व्यावसायिक तर्क में इन भागों में से एक है, तो आप अपने लूप के for संबंधित घटक को छोड़ सकते हैं।

int i = obj.getLastestValue(); // i value is fetched from a method
    
for (; i < 100; i++) { // here initialization is not done
    System.out.println(i);
}

के for (;;) { function-body } संरचना while (true) लूप के बराबर है।

Nested For Loops

किसी भी लूपिंग स्टेटमेंट में नेस्टेड लूप के अंदर एक और लूप स्टेटमेंट होता है। अधिक आंतरिक लूप वाले लूपिंग के लिए इसी तरह 'नेस्टेड फॉर लूप' कहा जाता है।

    for(;;){
        //Outer Loop Statements
        for(;;){
            //Inner Loop Statements
        }
        //Outer Loop Statements
    }

लूप के लिए नेस्टेड को त्रिकोण आकार की संख्याओं को प्रिंट करने के लिए प्रदर्शित किया जा सकता है।

for(int i=9;i>0;i--){//Outer Loop
    System.out.println();
    for(int k=i;k>0;k--){//Inner Loop -1
        System.out.print(" ");
    }
    for(int j=i;j<=9;j++){//Inner Loop -2
        System.out.print(" "+j);
    }
 }

जबकि लूप्स

int i = 0;
while (i < 100) { // condition gets checked BEFORE the loop body executes
    System.out.println(i);
    i++;
}

while तक कोष्ठक के अंदर की स्थिति true होती true while लूप चलता true । इसे "प्री-टेस्ट लूप" संरचना भी कहा जाता है क्योंकि सशर्त बयान को मुख्य लूप शरीर द्वारा हर बार प्रदर्शन करने से पहले पूरा किया जाना चाहिए।

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

करते हैं ... जबकि लूप

do...while लूप अन्य छोरों से भिन्न होता है, इसमें कम से कम एक बार निष्पादित करने की गारंटी है। इसे "पोस्ट-टेस्ट लूप" संरचना भी कहा जाता है क्योंकि मुख्य लूप शरीर के बाद सशर्त बयान किया जाता है।

int i = 0;
do {
    i++;
    System.out.println(i);
} while (i < 100); // Condition gets checked AFTER the content of the loop executes.

इस उदाहरण में, लूप तब तक चलेगा जब तक कि 100 नंबर प्रिंट नहीं हो जाता है (भले ही हालत i < 100 और i <= 100 ), क्योंकि लूप की स्थिति का मूल्यांकन लूप निष्पादित होने के बाद किया जाता है।

कम से कम एक निष्पादन की गारंटी के साथ, लूप के बाहर चर घोषित करना और उन्हें अंदर से प्रारंभ करना संभव है।

String theWord;
Scanner scan = new Scanner(System.in);
do {
    theWord = scan.nextLine();
} while (!theWord.equals("Bird"));

System.out.println(theWord);

इस संदर्भ में , theWord को लूप के बाहर परिभाषित किया गया है, लेकिन चूंकि इसकी प्राकृतिक प्रवाह के आधार पर एक मूल्य होने की गारंटी है, theWord को आरंभीकृत किया जाएगा।

प्रत्येक के लिए

List strings = new ArrayList();
        
strings.add("This");
strings.add("is");
strings.add("a for-each loop");
        
for (String string : strings) {
    System.out.println(string);
}

T elements = ...
for (S s : elements) {
}

यदि नहीं तो

int i = 2;
if (i < 2) {
  System.out.println("i is less than 2");
} else {
  System.out.println("i is greater than 2");
}

if कोई कथन कोष्ठक में स्थिति के परिणाम के आधार पर सशर्त रूप से कोड निष्पादित करता है। जब कोष्ठक में स्थिति सही होती है तो यह उस कथन के ब्लॉक में प्रवेश करेगा, जिसे { और } जैसे घुंघराले ब्रेसिज़ द्वारा परिभाषित किया गया है। क्लोजिंग ब्रैकेट तक ब्रैकेट खोलना, यदि स्टेटमेंट का स्कोप है।

else ब्लॉक वैकल्पिक है और इसे छोड़ा जा सकता है। if बयान false है तो यह चलता है और if कथन सही है if नहीं चलता है क्योंकि if उस स्थिति में बयान निष्पादित होता है।

इन्हें भी देखें: टर्नरी अगर

स्विच स्टेटमेंट

switch स्टेटमेंट जावा का मल्टी-वे ब्रांच स्टेटमेंट है। यह लंबे समय से की जगह लेने के लिए प्रयोग किया जाता है if - else if - else चेन, और उन्हें और अधिक पठनीय बनाने के। हालांकि, if बयानों के विपरीत, कोई असमानताओं का उपयोग नहीं कर सकता है; प्रत्येक मान समवर्ती रूप से परिभाषित किया जाना चाहिए।

switch स्टेटमेंट में तीन महत्वपूर्ण घटक हैं:

• case : यह वह मान है जो switch स्टेटमेंट के तर्क के साथ तुल्यता के लिए मूल्यांकन किया जाता है।
• default : यह एक वैकल्पिक, कैच-ऑल अभिव्यक्ति है, में से कोई भी चाहिए case बयानों का मूल्यांकन true ।
• case स्टेटमेंट का अचानक पूरा होना; आमतौर पर break : यह आगे के case बयानों के अवांछित मूल्यांकन को रोकने के लिए आवश्यक है।

continue के अपवाद के साथ, किसी भी बयान का उपयोग करना संभव है जो एक बयान के अचानक पूरा होने का कारण होगा। यह भी शामिल है:

• break
• return
• throw

नीचे दिए गए उदाहरण में, एक सामान्य switch स्टेटमेंट चार संभावित मामलों के साथ लिखा गया है, जिसमें default भी शामिल default ।

Scanner scan = new Scanner(System.in);
int i = scan.nextInt();
switch (i) {
    case 0:
        System.out.println("i is zero");
        break;
    case 1:
        System.out.println("i is one");
        break;
    case 2:
        System.out.println("i is two");
        break;
    default:
        System.out.println("i is less than zero or greater than two");
}

को छोड़ते हुए करके break या किसी बयान जो अचानक पूरा होने के, हम लाभ उठा सकते हैं क्या "के रूप में गिर के माध्यम से" मामलों, जो कई मूल्यों के खिलाफ मूल्यांकन जाना जाता है। इसका उपयोग किसी मूल्य के विरुद्ध सफल होने के लिए पर्वतमाला बनाने के लिए किया जा सकता है, लेकिन यह अभी भी असमानताओं की तरह लचीला नहीं है।

Scanner scan = new Scanner(System.in);
int foo = scan.nextInt();
switch(foo) {
    case 1:
        System.out.println("I'm equal or greater than one");
    case 2:
    case 3:    
        System.out.println("I'm one, two, or three");
        break;
    default:
        System.out.println("I'm not either one, two, or three");
}

foo == 1 के मामले में आउटपुट होगा:

I'm equal or greater than one
I'm one, two, or three

foo == 3 के मामले में आउटपुट होगा:

I'm one, two, or three

enum Option {
    BLUE_PILL,
    RED_PILL
}

public void takeOne(Option option) {
    switch(option) {
        case BLUE_PILL:
            System.out.println("Story ends, wake up, believe whatever you want.");
            break;
        case RED_PILL:
            System.out.println("I show you how deep the rabbit hole goes.");
            break;
            
    }
}

public void rhymingGame(String phrase) {
    switch (phrase) {
        case "apples and pears":
            System.out.println("Stairs");
            break;
        case "lorry":
            System.out.println("truck");
            break;
        default:
            System.out.println("Don't know any more");
    }
}

टर्नरी ऑपरेटर

कभी-कभी आपको एक शर्त के लिए जांच करनी होगी और एक चर का मूल्य निर्धारित करना होगा।

पूर्व के लिए।

String name;

if (A > B) {
    name = "Billy";
} else {
    name = "Jimmy";
}

इसे एक पंक्ति में आसानी से लिखा जा सकता है

String name = A > B ? "Billy" : "Jimmy";

चर का मान शर्त के तुरंत बाद मान पर सेट होता है, यदि स्थिति सत्य है। यदि स्थिति झूठी है, तो चर को दूसरा मान दिया जाएगा।

टूटना

break बयान एक पाश समाप्त होता है (जैसे for , while या) एक के मूल्यांकन स्विच बयान ।

लूप:

while(true) {
   if(someCondition == 5) {
       break;
   }
}

उदाहरण में पाश हमेशा के लिए चलेगा। लेकिन जब कुछ someCondition निष्पादन के कुछ बिंदु पर 5 बराबर होता है, तो लूप समाप्त हो जाता है।

यदि कई छोरों को कैस्केड किया जाता है, तो break का उपयोग करके केवल सबसे आंतरिक लूप समाप्त होता है।

कोशिश करो ... पकड़ो ... अंत में

try { ... } catch ( ... ) { ... } नियंत्रण संरचना का उपयोग अपवादों को संभालने के लिए किया जाता है।

String age_input = "abc";
try {
    int age = Integer.parseInt(age_input);
    if (age >= 18) {
        System.out.println("You can vote!");
    } else {
        System.out.println("Sorry, you can't vote yet.");
    }
} catch (NumberFormatException ex) {
    System.err.println("Invalid input.  '" + age_input + "' is not a valid integer.");
}

यह प्रिंट होगा:

अमान्य निवेश। 'एबीसी' एक वैध पूर्णांक नहीं है।

finally में catch बाद क्लॉज जोड़ा जा सकता है। finally क्लॉज़ को हमेशा निष्पादित किया जाएगा, भले ही एक अपवाद फेंक दिया गया हो।

try { ... } catch ( ... ) { ... } finally { ... }

String age_input = "abc";
try {
    int age = Integer.parseInt(age_input);
    if (age >= 18) {
        System.out.println("You can vote!");
    } else {
        System.out.println("Sorry, you can't vote yet.");
    }
} catch (NumberFormatException ex) {
    System.err.println("Invalid input.  '" + age_input + "' is not a valid integer.");
} finally {
    System.out.println("This code will always be run, even if an exception is thrown");
}

यह प्रिंट होगा:

अमान्य निवेश। 'एबीसी' एक वैध पूर्णांक नहीं है।
यह कोड हमेशा चलाया जाएगा, भले ही एक अपवाद फेंक दिया गया हो

नेस्टेड ब्रेक / जारी

लेबल स्टेटमेंट का उपयोग करके बाहरी लूप को break / continue संभव है:

outerloop:
for(...) {
    innerloop:
    for(...) {
        if(condition1)
            break outerloop;

        if(condition2)
            continue innerloop; // equivalent to: continue;
    }
}

जावा में लेबल के लिए कोई अन्य उपयोग नहीं है।

जावा में स्टेटमेंट जारी रखें

जारी बयान का उपयोग वर्तमान पुनरावृत्ति में शेष चरणों को छोड़ने और अगले लूप पुनरावृत्ति के साथ शुरू करने के लिए किया जाता है। नियंत्रण continue स्टेटमेंट से स्टेप वैल्यू (इंक्रीमेंट या डिक्रीमेंट) तक जाता है, यदि कोई हो।

String[] programmers = {"Adrian", "Paul", "John", "Harry"};

    //john is not printed out
    for (String name : programmers) {
        if (name.equals("John"))
            continue;
        System.out.println(name);
    }

continue स्टेटमेंट प्रोग्राम नामित नाम के लूप के स्टेप वैल्यू (यदि कोई हो) को भी नियंत्रित कर सकता है:

Outer: // The name of the outermost loop is kept here as 'Outer'
for(int i = 0; i < 5; )
{
    for(int j = 0; j < 5; j++)
    {
        continue Outer;
    }
}