אינסופי עבור (לולאה) ג 'אווה

ב- Java, כמו בכל שפה כמעטתכנות, ישנם כלים כדי להבטיח את החזרה של חתיכת קוד מסוים, או, כפי שהם נקראים, מחזורים. מחזורים בג'אווה מיוצגים על ידי אופרטורים כגון עבור ובזמן, כמו גם הזנים שלהם. ככלל, מחזורי משמשים לעבור מערכים חד מימדי רב ממדי ומבני נתונים איטרציה (כולל אוספים) על מנת למצוא אלמנטים מסוימים פעולות נוספות איתם. עם זאת, זו אינה הדרך היחידה להשתמש בכלי כמו לולאה Java. דוגמאות לשימוש ינתנו כפי שהן נחשבות.

מחזור בעוד Java: תיאור ודוגמאות

הצהרת המחזור הבסיסית ב- Java היאבעוד. קטע הקוד הקבוע בגופו יחזור על עצמו עד למצב הביטוי הקבוע בסוגריים לאחר שיספק את הערך הלוגי של האמת. הצורה הכללית של ההצהרה בזמן היא:

בעוד (מצב) {

// הגוף של הלולאה

}

ברגע שהערך של המצב הלוגי חדל להיות אמיתי, הקוד המצורף בגוף הלולאה יפסיק לבצע ושליטה תועבר לקו הבא.

אם יש רק מפעיל אחד בגוף הלולאה,אז את הפלטה מסולסלים לא ניתן להגדיר, אבל זה נחשב טופס טוב אם הם תמיד עומדים. האיור לעיל מראה תרשים בלוק של המבצע של מפעיל זה.

לקבלת הבהירות, הבה נבחן את הדוגמה המוצגת באיור שלהלן:

מספר המשתנים המוצהר כוללערך 1. לאחר מכן, אנו רואים ביטוי הגיוני מוקף בסוגריים לאחר שם המפעיל. זה יהיה נכון, כלומר החזרה נכונה עד שהספירה קטנה או שווה ל - .10 בגוף הלולאה, עם כל איטרציה, הערך של המשתנה מתרחב ב - 1 ומוצג במסך המסוף. שים לב שכאשר הערך של המשתנה הגיע ל -11, המחזור הפסיק לפעול.

אם הערך של הספירה משתנה היה בתחילה שווה ל 11, אז המצב לולאה יהיה שקר, והתוכנית אפילו לא להיכנס לגופו.

ראוי לציין כי תחביר ג 'אווה מאפשרלהשתמש בהצהרה בזמן ללא גוף. תן לנו לתת דוגמה. נניח שיש לנו שני משתנים i = 100 ו- j = 200, אנו מתמודדים עם המשימה של חישוב פרוגרמטי של הממוצע האריתמטי שלהם - ניתן להשתמש ב "חלול" בזמן:

בעוד (++ i <- j);

כתוצאה מכך, שוויו של כל אחד משני המשתנים יהיה שווה לממוצע הערכים המקוריים שלהם. כפי שניתן לראות, המחזור עבד בצורה מושלמת ללא גוף וביצע את כל הפעולות הדרושות בביטוי מותנה.

לעשות בזמן לולאה

בדוגמאות הקודמות, אם הביטוי המותנהבתחילה חזר שווא, ביצוע התוכנית תתעלם הגוף של הלולאה וללכת רחוק יותר. עם זאת, לעתים קרובות יש מצבים שבהם ביצוע הקוד הכלול בגוף הלולאה, בהכרח לפחות פעם אחת, ללא קשר לתקפות הביטוי המותנה. במילים אחרות, זה קורה כי אין צורך לבדוק את תוקפו של ביטוי מותנה בהתחלה, אבל בסוף מחזור. פונקציונליות זו יכולה להיות מסופקת על ידי סוג של לולאה בזמן שנקרא לעשות בזמן. יש לה את הטופס הבא:

לעשות {
// הגוף של הלולאה

} בעוד (מצב);

כפי שאנו יכולים לראות, הגוף לולאה הוא הראשון להורג, ורק אז היא האמת של המצב בדק - וכך הלאה כל איטרציה.

הקוד לעיל יעבוד ככהכמו במקרה עם הרגיל בזמן. עם זאת, אם נתנו למשתנה הספירה ערך של 11, גוף הלולאה עדיין יבוצע פעם אחת לפני שהמפעיל יוכל לאמת את תוקפו של הביטוי.

תיאור ודוגמאות עבור - מחזור ג 'אווה

לולאה הוא אוניברסליצורת שפה יעילה ב- Java. לפני הגרסה החמישית של ה- SDK של Java, היה רק ​​טופס מסורתי אחד להצהרה, ולאחר מכן גרסה חדשה עבור כל אחת. בסעיף זה אנו מכירים את הצורה המסורתית של המפעיל. עבור Java, הלולאה נראית כך:

לפני שליטה ניתנת קוד בגוףמחזור, אתחול של המשתנה i, אשר פועל כמו מונה, מבוצע לראשונה. לאחר מכן, אנו בודקים את הביטוי המותנה שבו הדלפק מושווה לערך מסוים, ואם הוא חוזר נכון, הגוף לולאה מבוצע. לאחר מכן ערך הדלפק משתנה לשלב מוגדר מראש, הביטוי המותנה נבדק שוב, וכן הלאה עד שהמצב הופך לשקר. תרשים זרימה להלן ממחיש את כל השלבים של המחזור.

כדי להבין טוב יותר, בואו לתת דוגמה של איך לולאה Java עובד:

אנו רואים כי הדלפק משמשמשתנה loopVal. לאחר כל איטרציה של הלולאה, הערך שלה יוסיף ב -1, וזה יתרחש עד שיגיע ל -11. שים לב שגם משתנה הבקרה יכול להיות מוצהר מחוץ להצהרה, אבל אם לא תשתמש במשתנה זה בכל מקום למעט בלולאה, מומלץ להצהיר על כך ישירות בהצהרה. יש לזכור כי המשתנה המוצהר בהצהרה עצמה יש היקף בתוך לולאה זהה.

יש מצבים שבהם אתה רוצה להכריזמספר משתנים השולטים במחזור. עבור Java, לולאה מאפשרת לך לציין שני משתנים או יותר המופרדים באמצעות פסיק, ועושים זאת הן במהלך האתחול והן באיטרציה. מפעיל כזה יהיה הטופס הבא:

עבור (int i = 1, int j = 10; i <j; ++ i, --j) {}

בכל איטרציה, ערך המשתנה i יגדל ב -1, וערך המשתנה j יקטן ב -1. האיטרציות יבוצעו עד שאהיה גדול או שווה ל- j.

תכונות של שימוש בהצהרה

לולאה היא די גמישהבנייה, שכן כל שלושת החלקים שלה (אתחול, מצב, תוספת / הפחתה) לא ניתן להשתמש למטרה המיועד שלה. לדוגמה, במקום ביטוי מותנה עם משתנה בקרה, ניתן להחליף כל משתנה לוגי.

יציאה בוליאנית = false;

עבור (int i = 0; יציאה; ++ i) {

יציאה = true;

}

בדוגמה לעיל, אנו יכולים לראות כיצד העבודהמחזור הוא עצמאי לחלוטין של משתנה i, ומספר האיטרציות תלוי אך ורק כאשר משתנה היציאה יהיה נכון. יתר על כן, משתנה הבקרה ניתן להסיר לחלוטין את הלולאה וזה לא משפיע על הפעולה שלה: עבור (; יציאה;) {}. אמנם זה לא הדרך הסבירה ביותר של תכנות, לפעמים זה יכול להיות שימושי. העיקר הוא לספק מצב שבו המשתנה לוקח את הערך הדרוש כדי לצאת את הלולאה, כדי לא להפוך אותו ערך אינסופי.

עבור Java, לולאה יכול להיות הכריז וכךway: (;;;) {}. זוהי דוגמה טיפוסית של לולאה אינסופית עם תנאים מיוחדים להפריע. על איך להפריע את זה סוג של מחזורי, נדבר קצת מאוחר יותר.

מחזור בסגנון לכל

לולאה Java foreach משמש תמידחיפוש רציף של אלמנטים של המערך או מבנה נתונים מסוימים וביצוע פעולות חוזרות מסוימות עליהם. דוגמה לטופס זה של ההצהרה מוצגת להלן:

משתנה האיטרציה מוכרזשם, ואת המערך שהוכרז בעבר של שמות מחרוזת משמש כארגומנט השני של המפעיל. שם המשתנה ייקח לסירוגין את הערכים של כל אלמנט במערך עד שכל האלמנטים שלו יחולצו. יש לציין כי סוג המשתנה חייב להיות תואם לסוג האלמנטים המאוחסנים במערך. כמו כן, משתנה השם הוא לקריאה בלבד, וניסיון לשנות אותו לא ישנה את האלמנט עצמו במערך.

מפעילי מחזור פסיקה

ישנם שלושה מפעילי interrupt עבור לולאה: לשבור, לחזור ולהמשיך. שני הראשונים מסוגלים להפריע לחלוטין את הלולאה, ולהמשיך קטע רק את הפעולה של איטרציה הנוכחי. אם אתה משתמש במחזור Java אינסופי בקוד שלך, המפעילים האלה חייבים להיות נוכחים בו. חשבו על דוגמה פשוטה לשימוש בשבר:

למרות 11 איטרציות מסופקים בהצהרה זו, רק 8 יבוצע, כי כאשר הדלפק הוא 7, המצב בגוף שבו יש משפט הפסקה יעבוד.

ההצהרה לחזור פועלת באופן דומה, עם ההבדל זה לא רק מספק יציאה מ לולאה ג 'אווה, אלא גם מן השיטה שבה לולאה זו ממוקמת.

באמצעות הפסקה כמו goto

יש לזכור כי הפסקה קוטעת את העבודהרק המעגל שבגופו הוא ממוקם ישירות, כלומר. אם אתה משתמש בו בלולאה מקוננת, הלולאה החיצונית לא תפסיק לפעול. לשם כך, משפט הפסקה יכול לשמש כצורה תרבותית של goto.

בגרסה זו, מפעיל זה משמשחבילה עם תווית המאפשרת לך לארגן את הפלט לא רק ממחזורים, אלא מכל גוש קוד. תווית היא מזהה בשם מתאים עם נקודתיים אחרי זה. התווית מוצהרת בתחילת גוש הקוד המסומן. כדי להפריע לביצוע של בלוק מסומן, במקום הנכון, עליך להצהיר: break name_name. שקול את הדוגמה בתרשים להלן:

קוד יש שלושה בלוקים שכותרתו אחד,שניים ושלושה, בהתאמה. הצהרת הפסקה עם התווית שני מקוננת בכל שלושת הקוביות, אבל כאשר היא מופעלת התוכנית תצא מן שלוש ו שני בלוקים ולהמשיך בביצוע בלוק אחד. כלומר. במסוף נראו שתי הודעות: שלוש ואחת.

מסקנה

התוודענו למושג המחזורים בג'אווה,הראשי בזמן ו עבור הצהרות, כמו גם לעשות בזמן שלהם עבור כל צורות, בהתאמה. כדי להבין טוב יותר, אנו ממליצים לך לעשות תרגילים באמצעות אופרטורים אלה בצורות שונות, כמו גם דרכים שונות להפריע להם ולעבור בין בלוק אחד למשנהו.