हमारे सबसे पहले प्रोग्राम निर्देशों का एक क्रम थे जिन्हें एक के बाद एक निष्पादित किया जाता है। कोई कांटा नहीं। इसमें हैलोवर्ल्ड शामिल है, जो ग्रीटिंग प्रदर्शित करता है। इसमें अंकगणितीय गणनाएं शामिल हैं। हमारे पहले कार्यक्रमों के बाद, हमने सीखा कि शाखा कैसे की जाती है, अर्थात किसी कार्यक्रम को विशिष्ट परिस्थितियों के आधार पर अलग-अलग कार्य करने के लिए कैसे तैयार किया जाता है। यहां केंद्रीय हीटिंग और एयर कंडीशनिंग सिस्टम को नियंत्रित करने के लिए कोड दिया गया है:
मान लीजिए कि आपके पास दस सेब, दो हाथ और एक चाकू है। वास्तविक जीवन में, आप प्रत्येक सेब के लिए समान एल्गोरिथ्म का पालन करते हुए क्रमिक रूप से पूरे दर्जन को छीलते हैं। लेकिन हम कैसे एक कार्यक्रम प्रत्येक सेब के लिए एक दोहरावदार कार्रवाई करते हैं?
जारी रखना।
if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort)
heaterOn();
अगला कदम उठाएं। रोजमर्रा की जिंदगी में, हम अक्सर समान दोहराए जाने वाले कार्यों को करते हैं, उदाहरण के लिए, पाई के लिए सेब छीलना। इस आकर्षक प्रक्रिया को इस प्रकार वर्णित किया जा सकता है:
-
यदि कटोरे में सेब हैं, तो हम चरण 1.1 से 1.4 तक निष्पादित करते हैं:
- 1.1। एक सेब लो
- 1.2। इसे छीलकर स्लाइस में काट लें
- 1.3। एक पैन में सेब के स्लाइस को पाई क्रस्ट में व्यवस्थित करें
- 1.4। चरण 1 पर लौटें।

- हम खुद को सेबों की संख्या से जोड़ लेते हैं, लेकिन अगर हमारे पास पर्याप्त संख्या में सेब नहीं हैं, तो कुछ कमांड "पेलोड" के बिना निष्पादित किए जाएंगे (और हम एक गैर-मौजूद सेब को छीलने की कोशिश करते हुए खुद को काट सकते हैं)।
- यदि छीलने के आदेश से अधिक सेब हैं, तो कुछ सेब बिना छिलके के रह जाएंगे।
- ऐसा कोड पढ़ना मुश्किल है। इसमें बहुत सारे दोहराव हैं और इसे संशोधित करना मुश्किल है।
लूप ऐसे कथन होते हैं जो क्रियाओं को बार-बार करने की अनुमति देते हैं
जावा का जबकि लूप हमारे मामले में अच्छा काम करेगा। यह निर्माण कई कार्रवाइयों को एक संक्षिप्त और समझने योग्य संरचना में डालता है। थोड़ी देर लूप का उपयोग करके , पाई के लिए एक सेब-स्लाइसिंग एल्गोरिदम जावा में ऐसा दिख सकता है:
while (numberOfApplesInBowl > 0) {
apple = bowl.grabNextApple();
arrangeInPie(apple.peel().slice());
numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");
कमांड सिंटैक्स
जबकि कथन का पहला संस्करण इस प्रकार है:
while (Boolean expression) {
// Loop body — the statement(s) that are repeatedly executed
}
इस कोड के निष्पादित होने पर क्या होता है, इसकी चरण-दर-चरण व्याख्या यहां दी गई है:
- हम थोड़ी देर के कीवर्ड के बाद कोष्ठक में पाए जाने वाले बूलियन अभिव्यक्ति का मूल्यांकन करते हैं ।
- यदि बूलियन अभिव्यक्ति सत्य का मूल्यांकन करती है, तो लूप बॉडी में बयानों को निष्पादित किया जाता है। लूप बॉडी में अंतिम स्टेटमेंट निष्पादित होने के बाद, हम चरण 1 पर जाते हैं
- यदि बूलियन व्यंजक असत्य का मूल्यांकन करता है, तो हम while लूप के बाद पहले कथन पर सीधे जाते हैं।
एक पूर्व शर्त के साथ लूप
क्योंकि हम हमेशा लूप बॉडी को निष्पादित करने से पहले बूलियन एक्सप्रेशन (लूप में प्रवेश करने की स्थिति) का मूल्यांकन करते हैं , जबकि लूप के इस रूप को अक्सर पूर्व शर्त के साथ लूप कहा जाता है । आइए किसी संख्या की पहली दस घातों की एक तालिका बनाएँ:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = 1; // The result of exponentiation
int exponent = 1; // The initial exponent
while (exponent <= 10) { // The condition for entering the loop
result = result * base;
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
}
}
कंसोल आउटपुट:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0
पोस्टकंडिशन के साथ लूप
यहाँ इस पाश का दूसरा संस्करण है:
do {
// Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
इस कोड के निष्पादित होने पर क्या होता है, इसकी व्याख्या यहां दी गई है:
- लूप बॉडी को निष्पादित किया जाता है ( डू कीवर्ड के तुरंत बाद)।
- हम थोड़ी देर के कीवर्ड के बाद कोष्ठक में पाए जाने वाले बूलियन अभिव्यक्ति का मूल्यांकन करते हैं ।
- यदि बूलियन व्यंजक सत्य का मूल्यांकन करता है, तो हम चरण 1 पर जाते हैं
- यदि बूलियन व्यंजक असत्य का मूल्यांकन करता है, तो हम while लूप के बाद पहले कथन पर सीधे जाते हैं।
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = base; // The result of exponentiation
int exponent = 1; // The initial exponent
do {
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
result = result * base;
} while (result < 10000); // The condition for exiting the loop
}
कंसोल आउटपुट:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
कोड में बदलाव पर ध्यान दें। इसकी तुलना पूर्व शर्त वाले लूप से करें।
लूप के साथ काम करने के बारे में रोचक तथ्य
लूप बॉडी के भीतर ब्रांचिंग स्टेटमेंट
लूप के भीतर निष्पादन को प्रभावित करने वाले दो कथन हैं: ब्रेक (जिस पर हम अगले अध्याय में अधिक विस्तार से चर्चा करेंगे) और- जारी रखें - वर्तमान पुनरावृत्ति में शेष लूप बॉडी के निष्पादन को छोड़ देता है और जबकि स्टेटमेंट के बूलियन एक्सप्रेशन के मूल्यांकन के लिए कूद जाता है। यदि व्यंजक सत्य का मूल्यांकन करता है, तो लूप जारी रहता है।
- ब्रेक - वर्तमान पुनरावृत्ति के निष्पादन को तुरंत समाप्त कर देता है और लूप के बाद पहले कथन पर नियंत्रण स्थानांतरित कर देता है। इस प्रकार, यह कथन वर्तमान लूप के निष्पादन को समाप्त करता है। अगले लेख में हम इस पर और विस्तार से विचार करेंगे।
while (numberOfApplesInBowl > 0) {
apple = bowl.grabNextApple();
numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
if (apple.isBad()) { // This method returns true for rotten apples
apple.throwInGarbage();
continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
}
arrangeInPie(apple.peel().slice());
}
कंटिन्यू स्टेटमेंट का उपयोग अक्सर तब किया जाता है जब लूप बॉडी में स्टेटमेंट्स को निष्पादित करने की आवश्यकता होती है यदि एक निश्चित स्थिति संतुष्ट होती है
। उदाहरण के लिए, हो सकता है कि जब कोई हार्डवेयर सेंसर चालू हो जाए तो हम कार्रवाई करना चाहें (अन्यथा, बस उस लूप को जारी रखें जिसमें हम सेंसर रीडिंग लेते हैं) या हम केवल लूप के कुछ पुनरावृत्तियों पर एक एक्सप्रेशन की गणना करना चाहते हैं। बाद वाले मामले का एक उदाहरण हमारे द्वारा थोड़ी देर के लूप के उपयोग में देखा जा सकता है ताकि प्राकृतिक संख्याओं के घनों के योग की गणना की जा सके जिनका वर्ग संख्याओं की संख्या से कम है। अस्पष्ट? निम्नलिखित कोड देखें:
public static void main(String[] args) {
int sum = 0; // Total amount
int i = 0; // Initial number in the series
int count = 20; // Number of numbers
while (i <= count) {
i++; // Get the next number — "i++" is equivalent to "i = i + 1"
if (i * i <= count) // If the square of the number is less than
continue; // the number of numbers, then we won't calculate the sum
// Jump to the next number in the loop
sum += i * i * i; // Otherwise, we calculate the sum of the cubes of numbers
} // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
System.out.println(sum); // Print the result
}
अनंत लूप
इन ब्रांचिंग स्टेटमेंट का उपयोग अक्सर अनंत लूप में किया जाता है। यदि लूप से बाहर निकलने की बूलियन स्थिति कभी भी संतुष्ट नहीं होती है तो हम लूप को अनंत कहते हैं। कोड में, ऐसा कुछ दिखता है:
while (true) {
// Loop body
}
इस स्थिति में,
ब्रेक स्टेटमेंट हमें लूप से बाहर निकलने में मदद करता है। लूप के शरीर के बाहर निर्धारित बाहरी स्थितियों की प्रतीक्षा करते समय इस प्रकार का लूप उपयुक्त होता है। उदाहरण के लिए, ऑपरेटिंग सिस्टम या गेम में (लूप से बाहर निकलने का मतलब गेम से बाहर निकलना है)। या एल्गोरिदम का उपयोग करते समय, जो लूप के प्रत्येक पुनरावृत्ति के साथ, कुछ परिणाम सुधारने की कोशिश करते हैं, लेकिन बीता हुआ समय या बाहरी घटना (जैसे चेकर्स, शतरंज, या मौसम की भविष्यवाणी) के आधार पर पुनरावृत्तियों की संख्या को सीमित करते हैं। याद रखें कि सामान्य परिस्थितियों में अनंत लूप वांछनीय नहीं हैं। प्रदर्शित करने के लिए, घातांक पर लौटते हैं:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = 1; // The result of exponentiation
int exponent = 1; // The initial exponent
while (true) {
result = result * base;
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
if (exponent > 10)
break; // Exit the loop
}
}
कंसोल आउटपुट:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0
स्थिर फंदा
और अब हम लूप्स पर अपने अंतिम विषय पर आते हैं। उस सेब पाई को याद करें (मुझे आशा है कि आप इस समय भूखे नहीं हैं) और हमारा सेब छीलने वाला लूप:-
यदि कटोरे में सेब हैं, तो हम चरण 1.1 से 1.4 तक निष्पादित करते हैं:
- 1.1। एक सेब लो
- 1.2। इसे छीलकर स्लाइस में काट लें
- 1.3। एक पैन में सेब के स्लाइस को पाई क्रस्ट में व्यवस्थित करें
- 1.4। चरण 1 पर लौटें।
- स्लाइस की संख्या = 0
-
जब तक स्लाइस की संख्या < 12 है, तब चरण 2.1 से 2.3 करें
- 2.1। सेब का एक और टुकड़ा काट लें
- 2.2। स्लाइस की संख्या++
- 2.3। चरण 2 पर लौटें
-
यदि कटोरे में सेब हैं, तो हम चरण 1.1 से 1.6 तक निष्पादित करते हैं:
- 1.1। एक सेब लो
- 1.2। इसे छीलें
- 1.3। स्लाइस की संख्या = 0
- 1.4। जब तक स्लाइस की संख्या <12 है, तब तक चरण 1.4.1 से 1.4.3 तक करें
- 1.4.1। सेब का एक और टुकड़ा काट लें
- 1.4.2। स्लाइस की संख्या++ 1.4.3। 1.4 चरण पर लौटें
- 1.5। एक पैन में सेब के स्लाइस को पाई क्रस्ट में व्यवस्थित करें
- 1.6। चरण 1 पर लौटें।
public static void main(String[] args) {
// Print the second factors in a row
System.out.println(" 2 3 4 5 6 7 8 9");
int i = 2; // Assign the first factor to the variable
while (i < 10) { // First loop: execute as long as the first factor is less than 10
System.out.print(i + " | "); // Print the first factor at the beginning of the line
int j = 2; // The starting value of the second factor
while (j < 10) { // Second loop: execute as long as the second factor is less than 10
int product = i * j; // Calculate the product of the factors
if (product < 10) // If the product is a single digit, then we print two spaces after the product
System.out.print(product + " ");
else // Otherwise, print the product and one space after it
System.out.print(product + " ");
j++; // Increment the second factor by one
} // Go to the beginning of the second loop, i.e. "while (j < 10)"
System.out.println(); // Move to the next line on the console
i++; // Increment the first factor by one
} // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
कंसोल आउटपुट:
2 3 4 5 6 7 8 9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
लूप्स (विशेष रूप से,
जबकि स्टेटमेंट) सॉफ्टवेयर के मूलभूत बिल्डिंग ब्लॉक्स में से एक हैं। CodeGym पर कार्यों को हल करके, आप सभी विभिन्न प्रकार के लूप सीखेंगे, उनकी पेचीदगियों को समझेंगे, और उनका उपयोग करने में व्यावहारिक कौशल प्राप्त करेंगे।
GO TO FULL VERSION