לולאה, לעבור או לקחת הפסקה? החלטה ואיתור עם הצהרות Java

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

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

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

החלף ביטוי ב- Java 12

שים לב שמדריך זה עודכן עבור Java 12 וכולל מבוא קצר switchלביטויים.

הורד קבל את הקוד הורד את קוד המקור למשל יישומים במדריך זה. נוצר על ידי ג'ף פרייזן עבור JavaWorld.

הצהרות ומטלות משתנות

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

int age = 25; float interest_rate; char[] text = { 'J', 'a', 'v', 'a' }; String name;

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

שקול כעת את הצהרת ההקצאה , שקשורה קשר הדוק להצהרת ההצהרה המשתנה. משפט הקצאה מקצה ערך (אולי הפניה למערך או הפניה לאובייקט) למשתנה. הנה כמה דוגמאות:

age = 30; interest_rate = 4.0F; age += 10; text[1] = 'A'; text[2] = 'V'; text[3] = 'A'; name = "John Doe";

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

  • התקדמות מראש (למשל ++x;)
  • הקדמה מראש (למשל --y;)
  • פוסט תוספת (למשל x++;)
  • לאחר ירידה (למשל y--;)
  • שיחת שיטה (למשל System.out.println("Hello");)
  • יצירת אובייקט (למשל new String("ABC");)

הצהרות משתנות עם jshell

ניתן להשתמש בהם jshellכדי להתנסות בהצהרות משתנות והצהרות ביטוי. להלן מספר דוגמאות לתחילת העבודה (ראה "למד Java מהיסוד" להקדמה למעטפת Java):

jshell> int age = 25 age ==> 25 jshell> float interest_rate interest_rate ==> 0.0 jshell> char[] text = { 'J', 'a', 'v', 'a' } text ==> char[4] { 'J', 'a', 'v', 'a' } jshell> String name name ==> null jshell> age = 30 age ==> 30 jshell> interest_rate = 4.0F interest_rate ==> 4.0 jshell> age += 10 $7 ==> 40 jshell> text[1] = 'A' $8 ==> 'A' jshell> text[2] = 'V' $9 ==> 'V' jshell> text[3] = 'A' $10 ==> 'A' jshell> name = "John Doe" name ==> "John Doe" jshell> text text ==> char[4] { 'J', 'A', 'V', 'A' } jshell> age++ $13 ==> 40 jshell> age age ==> 41

שימו לב שלכאורה age++לא השלים דבר. הנה, אתה רואה 40שהוקצה למשתנה השריטה $13. עם זאת, מפעיל לאחר ההעלאה מבצע את התוספת לאחר החזרת הערך הנוכחי. (למעשה, היא שומרת את הערך הנוכחי איפשהו, מבצעת את התוספת ואז מחזירה את הערך המאוחסן.) הזנת הגיל מוכיחה ageשמכילה 41, תוצאה של פעולת לאחר ההעלאה.

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

jshell> /list 1 : int age = 25; 2 : float interest_rate; 3 : char[] text = { 'J', 'a', 'v', 'a' }; 4 : String name; 5 : age = 30 6 : interest_rate = 4.0F 7 : age += 10 8 : text[1] = 'A' 9 : text[2] = 'V' 10 : text[3] = 'A' 11 : name = "John Doe" 12 : text 13 : age++ 14 : age

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

jshell> /12 text text ==> char[4] { 'J', 'A', 'V', 'A' } jshell> /list 13 13 : age++ jshell> /drop 7 | dropped variable $7 jshell> /list 1 : int age = 25; 2 : float interest_rate; 3 : char[] text = { 'J', 'a', 'v', 'a' }; 4 : String name; 5 : age = 30 6 : interest_rate = 4.0F 8 : text[1] = 'A' 9 : text[2] = 'V' 10 : text[3] = 'A' 11 : name = "John Doe" 12 : text 13 : age++ 14 : age 15 : text

כאן נכנסנו / 12 לבצע מחדש את קטע מס '12, שמפיק את התוכן של text. לאחר מכן נכנסנו / רשימת 13 לרשימת קטע מס '13, אשר עולה age. לאחר מכן, הזנו / שחררנו 7 כדי למחוק את קטע מספר 7 (אין עוד age += 10קטע). לבסוף, נכנסנו / רשימה כדי לרשום מחדש את כל התוספים. שים לב שקטע 7 הוסר, וקטע 15 הוסף בזכות /12הפקודה.

קבלת החלטות: אם, אם-אחרת, והחלף

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

Java תומכת if, if-else, ו switchהצהרות ההחלטה. בנוסף, switchנוספה תכונת ביטויים חדשה ל- Java 12.

הצהרת ה- if

הפשוטה ביותר של הצהרות ההחלטה של ​​ג'אווה היא ifההצהרה, שמעריכה ביטוי בוליאני ומבצעת הצהרה אחרת כאשר ביטוי זה מוערך לאמיתי. ifההצהרה יש בתחביר הבא:

if (Boolean expression) statement

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

הדוגמה הבאה מדגימה את ifההצהרה. כאשר ageהמשתנה מכיל ערך של 55 ומעלה, ifמבצע System.out.println(...);להפעלת ההודעה:

if (age >= 55) System.out.println("You are or were eligible for early retirement.");

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

if (age >= 55) { System.out.println("You are or were eligible for early retirement."); }

למרות שהפלטה מבהירה את מה שמבוצע ifבהצהרה, אני סבור שהכניסה מספקת בהירות זו, וכי הפלטה מיותרת.

להתנסות בהצהרות if

בואו ננסה את הדוגמה הזו באמצעות jshell. הפעל מחדש jshellואז הציג ageמשתנה (מסוג int) שמאותחל ל 55:

jshell> int age = 55

לאחר מכן, הזן את ifמשפט הדוגמא הראשון (ללא הפלטה המתולתלת המקיפה את גופו):

jshell> if (age >= 55) ...> System.out.println("You are or were eligible for early retirement."); You are or were eligible for early retirement. jshell>

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

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

Now, suppose you assign 25 to age and then re-execute /2 (or the equivalent snippet number in your session). This time, you should not observe the message in the output.

The if-else statement

The if-else statement evaluates a Boolean expression and executes a statement. The statement executed depends on whether the expression evaluates to true or false. Here's the syntax for the if-else statement:

if (Boolean expression) statement1 else statement2

The if-else statement is similar to the if statement, but it includes the reserved word else, followed by a statement to execute when the Boolean expression is false.

The following example demonstrates an if-else statement that tells someone who is less than 55 years old how many years are left until early retirement:

if (age >= 55) System.out.println("You are or were eligible for early retirement."); else System.out.println("You have " + (55 - age) + " years to go until early retirement.");

Conditional operator vs if-else

The conditional operator (?:) is similar to an if-else statement. However, this operator cannot be used to execute alternate statements. Instead, it can only return one of two values of the same type. (The conditional operator is also sometimes known as the ternary operator.)

Chaining if-else statements

Java lets you chain multiple if-else statements together for situations where you need to choose one of multiple statements to execute:

if (Boolean expression1) statement1 else if (Boolean expression2) statement2 else ... else statementN

Chaining works by executing a subsequent if-else statement whenever the current if statement's Boolean expression evaluates to false. Consider a demonstration:

if (temperature  100.0) System.out.println("boiling"); else System.out.println("normal");

The first if-else statement determines if temperature's value is negative. If so, it executes System.out.println("freezing");. If not, it executes a second if-else statement.

The second if-else statement determines if temperature's value is greater than 100. If so, it executes System.out.println("boiling");. Otherwise, it executes System.out.println("normal");.

The dangling-else problem

When if and if-else are used together, and the source code isn't properly indented, it can be difficult to determine which if associates with the else. You can see the problem in the code below:

int x = 0; int y = 2; if (x > 0) if (y > 0) System.out.println("x > 0 and y > 0"); else System.out.println("x <= 0");

You would probably expect to see x <= 0 as the output from this code, but it will never happen; instead, nothing will output. The problem is that the else matches up to its nearest if, which is if (y > 0). Reformatting the code makes it clearer what is happening:

int x = 0; int y = 2; if (x > 0) if (y > 0) System.out.println("x > 0 and y > 0"); else System.out.println("x <= 0");

Here it's clearer than an if (y > 0) ... else ...if-else statement follows the if (x > 0) statement. To match the intent of the previous example, you need to introduce brace characters around if (y > 0) and its subsequent statement. Essentially, a block will follow if (x > 0):

int x = 0; int y = 2; if (x > 0) { if (y > 0) System.out.println("x > 0 and y > 0"); } else System.out.println("x <= 0");

Because x > 0 evaluates to false, System.out.println("x <= 0"); executes. The else reserved word clearly matches up to if (x > 0).

The switch statement

When you need to choose between several execution paths, the switch statement offers a more efficient alternative to chaining. Have a look at the switch statement:

switch (selector expression) { case value1: statement1 [break;] case value2: statement2 [break;] ... case valueN: statementN [break;] [default: statement] }

The switch statement begins with reserved word switch and continues with a selector expression that selects one of the subsequent cases or the default case to execute. The selector expression evaluates to an integer, a character, or a string.

Switch and enum constants

The selector expression can also evaluate to an enum constant. I'll introduce enums in a future tutorial.

כל מקרה מזהה הצהרה לביצוע. המקרה מתחיל במילה השמורה caseובערך שמתייג את המקרה. בעקבות דמות נקודתיים ( :) היא ההצהרה לביצוע. ניתן לבצע את ההצהרה באופן אופציונלי break;כדי להעביר את הביצוע להצהרה הראשונה שאחרי switch. אם אף אחת מתוויות המקרה אינה תואמת לערך ביטוי הבורר, מקרה הברירת המחדל האופציונלי, המתחיל במילה שמורה default, יבוצע.

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

int i = 27; switch (i % 2) { case 0: System.out.println("even"); break; case 1: System.out.println("odd"); }