(जावा) चक्र के लिए अंतहीन

जावा में, लगभग किसी भी प्रोग्रामिंग भाषा में की तरह, वहाँ उपकरण कोड का एक विशेष खंड के कई पुनरावृत्ति प्रदान करने के लिए के रूप में वे कहते हैं, चक्र हैं, या,। जावा में लूप्स के लिए और जब तक है, साथ ही उनके किस्मों के रूप में, ऑपरेटरों द्वारा प्रतिनिधित्व कर रहे हैं। आमतौर पर, चक्र एक आयामी और बहु-आयामी सरणियों और iterable डेटा संरचनाओं (संग्रह सहित) के पारित होने के कुछ वस्तुओं और उनके साथ आगे संचालन को खोजने के लिए किया जाता है। हालांकि, इस तरह के जावा के चक्र के रूप में एक उपकरण का उपयोग का एकमात्र तरीका नहीं है। प्रयोग के उदाहरण को विचार के रूप में प्रेरित किया जाएगा।

लूप जबकि जावा: विवरण और उदाहरण

जावा में मौलिक चक्र ऑपरेटर, जबकि है। कोड स्निपेट, उसके शरीर में संलग्न हालत अभिव्यक्ति, इसके बाद कोष्ठक में के रूप में रूप में लंबे समय दोहराया जाता है, तार्किक मान TRUE को संतुष्ट करेगा। थोड़ी देर के बयान के सामान्य रूप इस प्रकार है:

जबकि (हालत) {

// पाश शरीर

}

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

स्पष्टता के लिए, एक उदाहरण नीचे दिए गए चित्र में दिखाया गया पर ध्यान दें:

घोषित चर गिनती शुरू में 1. अगला पर सेट किया जाता है, हम एक तार्किक ऑपरेटर के नाम के बाद कोष्ठक में संलग्न अभिव्यक्ति देखते हैं। यह सच है, कि है, मान सच है, जब तक चर गिनती के मूल्य से कम या 10 के बराबर प्रत्येक पास (यात्रा) अलग-अलग मान 1 से वृद्धि और सांत्वना स्क्रीन पर प्रदर्शित किया जाता है के साथ पाश में है। ध्यान दें कि जब चर का मान 11 तक पहुँच गया है, चक्र काम करना बंद कर।

गिनती शुरू में 11 के बराबर का मूल्य, पाश हालत गलत हो, और चाहते हैं कार्यक्रम भी उसके शरीर में चला गया होता।

यह ध्यान देने योग्य है कि जावा वाक्य रचना एक शरीर के बिना, जबकि बयान के उपयोग की अनुमति के लायक है। यहाँ एक उदाहरण है। मान लीजिए कि हम दो चर मैं = 100 और j = 200, हम सॉफ्टवेयर के कार्य के साथ सामना कर रहे हैं उनके औसत की गणना करने के लिए करते हैं - आप "खोखला» जबकि उपयोग कर सकते हैं:

जबकि (++ i <- जे);

नतीजतन, दो चर में से किसी का मूल्य उनकी प्रारंभिक मूल्यों के औसत के बराबर होगा। आप देख सकते हैं, चक्र शरीर के बिना पूरी तरह से काम किया, और सशर्त अभिव्यक्ति में सभी आवश्यक कार्रवाई को अंजाम दिया।

do-, जबकि के चक्र

पिछले उदाहरण में, यदि सशर्त अभिव्यक्ति शुरू में झूठी दिया जाता है, तो कार्यक्रम पाश के शरीर पर ध्यान नहीं दिया और पर चला गया होता। हालांकि, कई बार ऐसी परिस्थितियाँ होती हैं, जिसमें पाश के शरीर में निहित कोड के निष्पादन, करने के लिए कम से कम एक बार सुनिश्चित हो, सशर्त अभिव्यक्ति की सच्चाई की परवाह किए बिना कर रहे हैं। दूसरे शब्दों में, यह है कि सशर्त अभिव्यक्ति की वैधता की जांच शुरुआत में और चक्र के अंत में की आवश्यकता नहीं है होता है। यह कार्यक्षमता थोड़ी देर के पाश do-, जबकि कहा जाता है का एक प्रकार प्रदान कर सकते हैं। यह निम्न रूप है:

करना {
// पाश शरीर

} एक ओर जहां (हालत);

हम देख सकते हैं, पहले, निष्पादन चक्र के लिए शरीर है, और उसके बाद ही जाँच की हालत सही है - और इसलिए प्रत्येक यात्रा।

कोड से ऊपर, लगभग एक पारंपरिक जबकि साथ मामले में के रूप में ही पूरा करता है। हालांकि, अगर हम 11 गिनती का एक मूल्य सौंपा, पाश शरीर अभी भी एक बार, ऑपरेटर अभिव्यक्ति की सच्चाई की पुष्टि कर सकते से पहले पूरा।

विवरण और उदाहरण के लिए - जावा चक्र

चक्र के लिए जावा के लिए एक बहुमुखी और कुशल भाषाई रूप है। इस समय तक जावा एसडीके के पांचवें संस्करण बयान के लिए का केवल एक ही पारंपरिक रूप था, और एक नया के बाद - प्रत्येक के लिए। इस खंड में, हम ऑपरेटर के परंपरागत स्वरूप से जानेंगे। जावा के लिए पाश इस प्रकार है:

इससे पहले कि नियंत्रण कोड पाश में स्थानांतरित कर दिया जाएगा पहले चर मैं initializes, काउंटर के रूप में सेवारत। इसके अलावा, सशर्त अभिव्यक्ति चेक किया गया है, जिसमें काउंटर एक निश्चित मूल्य के साथ तुलना की जाती है, और अगर यह सच देता है, शरीर निष्पादित किया जाता है। फिर, गिनती मूल्य एक पूर्व निर्धारित कदम से बदल गया है, और फिर से सशर्त अभिव्यक्ति और इतने पर जब तक हालत झूठी है की जाँच की। नीचे ब्लॉक आरेख चक्र के सभी चरणों को दिखाता है।

एक बेहतर समझ के लिए हम जावा के लिए कैसे चक्र का एक उदाहरण दे:

हम चाहते हैं कि loopVal चर में एक काउंटर के रूप में इस्तेमाल देखते हैं। प्रत्येक यात्रा के बाद, अपने मूल्य 1 से बड़ा हो जाएगा, और यह तब तक नहीं होगा, जब तक यह 11. ध्यान दें कि नियंत्रण चर बयान के लिए बाहर घोषित किया जा सकता तक पहुँच जाता है, लेकिन आप को छोड़कर कहीं भी इस चर का उपयोग नहीं करना चाहते हैं, तो चक्र में, यह बयान में सीधे यह घोषणा करने के लिए सलाह दी जाती है। ध्यान रखें कि एक चर बयान में घोषणा की यह एक ही चक्र के भीतर एक गुंजाइश है रखें।

बार जब आपके पास कई लूप नियंत्रण चर घोषित करने के लिए चाहते हैं। जावा पाश के लिए आप दो या अधिक चर, अल्पविराम के द्वारा अलग निर्दिष्ट करने के लिए, और उनके प्रारंभ में तो दोनों का उपयोग करना, और यात्रा के दौरान अनुमति देता है। इस तरह के एक ऑपरेटर निम्नलिखित हो जाएगा:

के लिए (int i = 1, इंट जे = 10; मैं j <; ++ मैं, --j) {}

प्रत्येक यात्रा पर, चर मैं 1 से वृद्धि की जाती है के मूल्य और चर j के मान 1 से कम कर रहा है पुनरावृत्तियों रूप में लंबे समय के रूप में मैं से अधिक या जे के बराबर है निष्पादित किया जाएगा।

बयान के लिए आवेदन की विशेषताएं

सभी तीन भागों (आरंभीकरण, हालत, और वेतन वृद्धि / कमी) ने अपने इच्छित उद्देश्य के लिए इस्तेमाल नहीं किया जा सकता है, क्योंकि चक्र के लिए काफी लचीला डिजाइन है। उदाहरण के लिए, नियंत्रण चर के साथ सशर्त अभिव्यक्ति के बजाय किसी भी बूलियन चर स्थानापन्न कर सकते हैं।

बूलियन बाहर निकलें = झूठी;

के लिए (int i = 0 ;! बाहर निकलें; ++ i) {

बाहर निकलने के = true

}

ऊपर के उदाहरण में हम देख सकते हैं कि कैसे काम चक्र मैं नियंत्रण चर से पूरी तरह से स्वतंत्र है और पुनरावृत्तियों की संख्या से बाहर निकलें चर के समय सही पर सेट हो जाएगा पर निर्भर करता है। इसके अलावा नियंत्रण चर पूरी तरह चक्र से हटाया जा सकता है, और यह अपने काम को प्रभावित नहीं करेगा: के लिए (; बाहर निकलें ;!) {}। हालांकि यह सबसे समझदार रास्ता कार्यक्रम नहीं है, यह कभी कभी उपयोगी हो सकता है। मुख्य बात - एक स्थिति है जिसमें चर चक्र मूल्य बाहर निकलने के लिए सही ले जाएगा के लिए प्रदान करने के लिए है, तो के रूप में एक अंतहीन में बारी करने नहीं।

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

प्रत्येक के लिए शैली में साइकिल

Foreach जावा चक्र हमेशा तत्वों या किसी की सरणी के अनुक्रमिक छंटाई के लिए प्रयोग किया जाता है डाटा संरचनाओं और उन्हें कुछ दोहराए कार्यों पर प्रदर्शन करते हैं। ऑपरेटर रूपों के लिए दिए गए उदाहरण नीचे प्रस्तुत कर रहे हैं:

एक यात्रा चर घोषित नाम के रूप में, एक पहले से घोषित नामों सरणी पंक्तियों ऑपरेटर दूसरा तर्क प्रदर्शन करती है। चर नाम बारी-बारी से सरणी के प्रत्येक तत्व के मूल्यों करने तक अपने सभी तत्वों को निकाले किया गया होगा। यह ध्यान देने योग्य है कि वैरिएबल प्रकार सरणी में संग्रहीत तत्वों के प्रकार के साथ संगत होना चाहिए। इसके अलावा, चर नाम पढ़ने और सरणी में तत्व का एक परिवर्तन करने के लिए नेतृत्व नहीं करेंगे इसे बदलने के लिए प्रयास के लिए विशेष रूप से उपलब्ध है।

ऑपरेटर्स चक्र रुकावट

तीन ऑपरेटर चक्र को बाधित कर रहे हैं: ब्रेक, वापसी और जारी रखें। पहले दो पूरी तरह से काम चक्र बाधा डालते हैं, और केवल वर्तमान यात्रा व्यवधान काम करना जारी करने में सक्षम हैं। आप अपने कोड जावा की जानबूझकर अंतहीन चक्र में उपयोग कर रहे हैं, इन ऑपरेटरों उस में मौजूद होना चाहिए। ब्रेक का उपयोग करने का एक सरल उदाहरण पर विचार करें:

हालांकि इस बयान 11 पुनरावृत्तियों के लिए प्रदान की जाती है, निष्पादित केवल 8, क्योंकि जब काउंटर मैं 7 के बराबर है, काम शर्त है जो शरीर एक ब्रेक बयान है।

वापसी ऑपरेटर अंतर यह है कि यह न केवल जावा का उत्पादन चक्र प्रदान करता है, लेकिन यह भी विधि है, जो इस चक्र में रखा गया है से के साथ एक समान तरीके से चल रही है।

ब्रेक का प्रयोग के रूप में गोटो

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

इस अवतार में, ऑपरेटर एक लेबल, जो न केवल चक्र के उत्पादन को व्यवस्थित करने के लिए अनुमति देता है के साथ संयोजन के रूप में प्रयोग किया जाता है, लेकिन यह भी किसी भी कोड ब्लॉक से। लेबल उचित रूप से यह के बाद एक कॉलन के साथ पहचानकर्ता नाम पर है। लेबल घोषित पर कोड ब्लॉक की शुरुआत की है। सही जगह में एक लेबल ब्लॉक के निष्पादन बाधित करने के लिए, आप यह घोषणा करने के लिए है: ब्रेक imya_metki। नीचे दिए गए उदाहरण पर विचार करें:

कोड में, लेबल एक, दो और तीन क्रमशः के साथ तीन ब्लॉक के नाम की घोषणा की। लेबल दो के साथ एक को तोड़ने बयान तीनों ब्लॉकों में एम्बेडेड है, लेकिन यह तीन और दो ब्लॉकों में से एक कार्यक्रम शुरू हो रहा है और एक इकाई में लागू करने के लिए जारी रहेगा। यानी तीन और एक: कंसोल में हम दो संदेश देखेंगे।

निष्कर्ष

हम थोड़ी देर और प्रमुख ऑपरेटरों, साथ ही do-, जबकि के अपने रूपों के लिए, और प्रत्येक के लिए क्रमश: जावा में चक्र की धारणा के साथ परिचित हैं,। एक बेहतर समझ के लिए हम विभिन्न रूपों, साथ ही उन्हें बीच में और एक ब्लॉक से दूसरे में स्थानांतरित करने के लिए अलग अलग तरीकों से इन ऑपरेटरों के उपयोग के साथ अभ्यास करने के लिए सलाह देते हैं।