שאלות על ראיונות עם בקרת זרימת Java (+ תשובות)

מאמר זה הוא חלק מסדרה: • שאלות ראיונות בנושא אוספי Java

• שאלות בנושא ראיונות מערכת מסוג Java

• שאלות על ראיונות במקביל ל- Java (+ תשובות)

• שאלות על ראיונות מבנה כיתת Java ו אתחול

• Java 8 שאלות ראיונות (+ תשובות)

• ניהול זיכרון בשאלות ראיון עם Java (+ תשובות)

• שאלות ראיונות עם Java Generics (+ תשובות)

• שאלות על ראיונות עם בקרת זרימת Java (+ תשובות) (מאמר נוכחי) • שאלות על ראיונות עם חריגות Java (+ תשובות)

• שאלות ראיונות בהערות Java (+ תשובות)

• שאלות על ראיונות מסגרת האביב המובילה

1. הקדמה

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

במאמר זה נעבור כמה שאלות ראיונות לבקרת זרימה שעלולות לצוץ במהלך ראיון ובמקרה המתאים; אנו מיישמים דוגמאות כדי להבין טוב יותר את תשובותיהם.

2. שאלות

שאלה 1. תאר את אם-אז ו אם-אז-אחרת הצהרות. אילו סוגי ביטויים יכולים לשמש כתנאים?

שתי ההצהרות אומרות לתוכנית שלנו לבצע את הקוד בתוכם רק אם תנאי מסוים מוערך נָכוֹן. אולם, ה אם-אז-אחרת הצהרה מספקת מסלול ביצוע משני במקרה שסעיף if מוערך ל שֶׁקֶר:

אם (גיל> = 21) {// ...} אחר {// ...}

בניגוד לשפות תכנות אחרות, ג'אווה תומכת רק בוליאני ביטויים כתנאים. אם ננסה להשתמש בביטוי מסוג אחר, נקבל שגיאת אוסף.

שאלה 2. תאר את החלף הַצהָרָה. באילו סוגי אובייקטים ניתן להשתמש ב- החלף סָעִיף?

Switch מאפשר בחירה של מספר נתיבי ביצוע המבוססים על ערך משתנים.

כל נתיב מתויג עם מקרה אוֹ בְּרִירַת מֶחדָל, ה החלף הצהרה מעריכה כל אחד מהם מקרה ביטוי להתאמה ומבצע את כל ההצהרות העוקבות אחר תווית ההתאמה עד א לשבור הצהרה נמצאת. אם הוא לא יכול למצוא התאמה, ה- בְּרִירַת מֶחדָל במקום זאת יבוצע חסימה:

switch (yearsOfJavaExperience) {case 0: System.out.println ("סטודנט"); לשבור; מקרה 1: System.out.println ("ג'וניור"); לשבור; מקרה 2: System.out.println ("אמצע"); לשבור; ברירת מחדל: System.out.println ("בכיר"); }

אנחנו יכולים להשתמש בתים, קצר, לְהַשְׁחִיר, int, הגרסאות שלהם עטופות, enums ו- חוּטs כמו החלף ערכים.

שאלה 3. מה קורה כשאנחנו שוכחים לשים a לשבור הצהרה בא מקרה סעיף של א החלף?

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

הנה דוגמה להדגמת זה:

מבצע int = 2; מספר int = 10; מתג (פעולה) {מקרה 1: מספר = מספר + 10; לשבור; מקרה 2: מספר = מספר - 4; מקרה 3: מספר = מספר / 3; מקרה 4: מספר = מספר * 10; לשבור; }

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

שאלה 4. מתי עדיף להשתמש ב- Sמְכַשֵׁפָה מעל אניf-Then-Else הצהרה ולהיפך?

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

החלף (חודש) {מקרה 1: מקרה 3: מקרה 5: מקרה 7: מקרה 8: מקרה 10: מקרה 12: ימים = 31; לשבור; מקרה 2: ימים = 28; לשבור; ברירת מחדל: ימים = 30; }

An אם-אז-אחרת הצהרה עדיפה כשאנחנו צריכים לבדוק טווחי ערכים או תנאים מרובים:

אם (aPassword == null || aPassword.isEmpty ()) {// סיסמה ריקה} אחרת אם (aPassword.length () <8 || aPassword.equals ("12345678")) {// סיסמה חלשה} אחר {/ / סיסמה טובה}

ש 5. באילו סוגי לולאות תומך Java?

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

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

עבור (int i = 0; i <10; i ++) {// ...}

א בזמן לולאה יכולה לבצע גוש הצהרות כאשר תנאי מסוים הוא נָכוֹן:

בעוד (iterator.hasNext ()) {// ...}

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

לעשות {// ...} תוך (בחירה! = -1);

שאלה 6. מה זה משופר עבור לוּלָאָה?

האם תחביר נוסף של ל הצהרה שנועדה לחזור דרך כל האלמנטים של אוסף, מערך, אומנות או כל אובייקט שמיישם את ניתן לנידון מִמְשָׁק:

עבור (String aString: arrayOfStrings) {// ...}

ש 7. איך תוכלו לצאת מצפוי מלולאה?

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

עבור (int i = 0;; i ++) {if (i> 10) {break; }}

ש 8. מה ההבדל בין תווית ללא תווית לשבור הַצהָרָה?

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

בואו ליצור דוגמה להדגמת זה:

int [] [] טבלה = {{1, 2, 3}, {25, 37, 49}, {55, 68, 93}}; בוליאני נמצא = שקר; int loopCycles = 0; חיצוני: for (int [] שורות: טבלה) {for (int שורה: שורות) {loopCycles ++; אם (שורה == 37) {נמצא = נכון; לשבור חיצוני; }}}

כאשר נמצא המספר 37, התווית לשבור ההצהרה מסיימת את החיצוניות ביותר ל לולאה, ולא מבוצעים יותר מחזורים. לכן, loopCycles מסתיים בערך 5.

עם זאת, ללא תווית לשבור רק מסיים את האמירה הפנימית ביותר, ומחזיר את זרם השליטה לקצה ביותר ל שממשיך את הלולאה אל הבא שׁוּרָה בתוך ה שולחן משתנה, מה שהופך את loopCycles לסיים עם ערך 8.

שאלה 9. מה ההבדל בין תווית ללא תווית לְהַמשִׁיך הַצהָרָה?

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

הנה דוגמה המדגימה זאת:

int [] [] טבלה = {{1, 15, 3}, {25, 15, 49}, {15, 68, 93}}; int loopCycles = 0; חיצוני: for (int [] שורות: טבלה) {for (int שורה: שורות) {loopCycles ++; אם (שורה == 15) {המשך חיצוני; }}}

הנימוק זהה לשאלה הקודמת. התווית לְהַמשִׁיך ההצהרה מסיימת את החיצוניות ביותר ל לוּלָאָה.

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

ש 10. תאר את זרימת הביצוע בתוך a נסה לתפוס סוף סוף לִבנוֹת.

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

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

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

שאלה 11. באילו מצבים ה סוף כל סוף לא ניתן לבצע חסימה?

כאשר ה- JVM מסתיים בזמן ביצוע ה- לְנַסוֹת אוֹ לתפוס חסימות, למשל, על ידי התקשרות System.exit (), או כאשר חוט הביצוע נקטע או נהרג, אז החסימה הסופית אינה מבוצעת.

שאלה 12. מה התוצאה של ביצוע הקוד הבא?

הקצאת ציבורי סטטי ציבורי () {int number = 1; נסה {number = 3; אם (נכון) {זרוק חריג חדש ("חריג למבחן"); } מספר = 2; } לתפוס (Exception exc) {מספר החזרה; } סוף סוף {number = 4; } מספר החזרה; } System.out.println (הקצאה ());

הקוד מוציא את המספר 3. למרות שה- סוף כל סוף בלוק מתבצע תמיד, זה קורה רק לאחר לְנַסוֹת חסום יציאות.

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

ש 13. באילו מצבים נסה סוף סוף ניתן להשתמש בבלוק גם כאשר ייתכן שלא יוצאים חריגים?

חסימה זו שימושית כאשר אנו רוצים להבטיח שלא נעקוף בטעות את ניקוי המשאבים המשמשים בקוד על ידי מפגש עם לשבור, לְהַמשִׁיך אוֹ לַחֲזוֹר הַצהָרָה:

HeavyProcess heavyProcess = HeavyProcess חדש (); נסה {// ... להחזיר heavyProcess.heavyTask (); } סוף סוף {heavyProcess.doCleanUp (); }

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

חלל ציבורי doDangerousTask (משימת משימה) זורק את ComplicatedException {נסה {// ... task.gatherResources (); אם (task.isComplicated ()) {זרוק ComplicatedException חדש ("קשה מדי"); } // ...} סוף סוף {task.freeResources (); }}

ש 14. איך נסה עם משאבים עֲבוֹדָה?

ה נסה עם משאבים הצהרה מצהירה ומאתחלת אחד או יותר מהמשאבים לפני ביצוע ה- לְנַסוֹת לחסום ולסגור אותם אוטומטית בסוף ההצהרה ללא קשר אם החסימה הושלמה כרגיל או באופן פתאומי. כל יישום אובייקט ניתן לסגירה אוטומטית אוֹ סגור ממשקים יכולים לשמש כמשאב:

נסה (סופר StringWriter = חדש StringWriter ()) {writer.write ("שלום עולם!"); }

3. מסקנה

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

בהצלחה בראיון שלך.

הַבָּא » שאלות ראיונות עם חריגות Java (+ תשובות) « שאלות ראיונות קודמות עם Java Generics (+ תשובות)