Java/תנאים

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

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

if (condition)
   Command;

כאשר במקום המילה condition נכתוב את התנאי שלנו. התנאי הוא תמיד בוליאני, כלומר - מסוגל להיות אמת (true), או שקר (false). כאשר התשובה חיובית (התנאי מתקיים) תופעל הפקודה שכתובה מיד אחרי התנאי, וכשהתשובה שלילית התוכנית תתעלם מהפקודה שאחרי פקודת ה-if, ותמשיך הלאה. לדוגמה:

if (x==5)
   System.out.println("X is 5");

תביא להדפסת המחרוזת "X is 5" אך ורק אם המשתנה x שווה ל-5. כל ערך אחר יגרום לתוכנית להמשיך הלאה. התנאי לא מוגבל לפקודה אחת: ניתן להשתמש בצומדיים ('{ }') כדי להגדיר קבוצת פקודות שתתבצענה אם יתקיים התנאי, בצורה הבאה:

if (condition) {
   Command 1;
   Command 2;
...
}

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

if (x == 5)
    System.out.println("X is 5");
else
    System.out.println("X is not 5");

בדוגמה זו אם X יהיה שווה ל-5 ההודעה "X is 5" תודפס, ואם X לא יהיה שווה ל-5 תודפס ההודעה "X is not 5".

תנאים מורכבים

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

• האופרטור "וגם" יהיה נכון אם ורק אם גם תנאי א' מתקיים וגם תנאי ב' מתקיים. בג'אווה אנו מסמנים אופרטור זה ב-"&&".
• האופרטור "או" יהיה נכון אם ורק אם אחד מהתנאים יתקיים. בג'אווה אנו מסמנים אופרטור זה ב-"||".
• סימן השלילה הופך את התנאי. בג'אווה אנו מסמנים זאת ב-"!".

הערה: ישנו סדר פעולות בסימנים הנ"ל בג'אווה קודם כל ! אח"כ && ואז ||. לדוגמה: התנאי((if((c1>64 && c1<92) || (c1>97 && c1<123 לא יכל להתקיים ללא הסוגריים הפנימיים שמפרידים בין הבדיקות.

דוגמאות

נניח ש-x הוא משתנה אותו הגדרנו להיות משתנה מסוג int.

if (x>4 && x<9)

הוא תנאי שיתקיים רק אם ערך המשתנה x נמצא בין 5 ל-8 (שימו לב: אם x שווה ל-4 או ל-9, התנאי לא מתקיים!)

if (x>4 || x<9)

הוא תנאי שיתקיים עבור כל x שהוא, מכיוון שכל מספר אפשרי הוא גדול מ-4 או קטן מ-9.

if (x<4 || x>9)

הוא תנאי שיתקיים עבור כל x שערכו קטן מ-4 או גדול מ-9.

if (!(x>4))

הוא תנאי שיתקיים עבור כל x שאינו גדול מ-4, כלומר - עבור כל x שקטן או שווה ל-4.

ניתן לחבר גם תנאים מורכבים יותר, כמו התנאי הבא:

if ((x<4 || x>9) && (y>15 && y<35))

כאשר גם y הוא משתנה מטיפוס int. תנאי כזה יתקיים רק אם יתקיים התנאי השמאלי, כלומר - x גדול מ-9 או קטן מ-4, וגם התנאי הימני, כלומר - y גדול מ-15 וקטן מ-35. בצורה זהה, ניתן לחבר מספר רב של תנאים בהתאם לצורך. בהמשך נראה דוגמאות שונות לכך - תנאים פשוטים ומורכבים.

תנאים מקוננים

ראינו כבר שבתוך בלוק תנאי ניתן לכתוב פקודות רבות. הבה נראה דוגמה, בהנחה ש-str הוא משתנה מוגדר מטיפוס String:

if (str.equals("Hello"))
	System.out.println("This is hello");

בדוגמה זו אנו בודקים אם המשתנה str שווה למחרוזת "Hello". מכיוון שאנו מתעסקים עם מחרוזות נעשה שימוש בפקודה equals במקום בצורת ההשוואה המוכרת (באמצעות סימני ה"=="). אם אכן str שווה למחרוזת זו, מודפס הפלט "This is hello".

באותה צורה בה כתבנו פקודות שיתבצעו אם יתקיים התנאי, ניתן גם לכתוב תנאים נוספים - תנאי בתוך תנאי. תנאים כאלה מכונים תנאים מקוננים, והם שימושיים מאוד בתכנות. נראה דוגמה דומה, והפעם עם תנאי מקונן (הפעם, str ו-str2, שניהם משתנים מוגדרים מטיפוס String):

if (str.equals("Hello"))
	if (str2.equals("World"))
		System.out.println("This is hello and world");

בדוגמה זו מתבצעות שתי בדיקות, בזו אחר זו: אם הבדיקה הראשונה מתקיימת, כלומר ערך המחרוזת str הוא "Hello", ממשיכה התוכנית לרוץ ולבדוק גם את התנאי השני, כלומר - בדיקה האם str2 שווה ל-"World". אם התנאי הראשון לא מתקיים - התנאי השני כלל לא נבדק.

ומה אם לא?

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

if (x>30 && y<10)
	System.out.println("It's OK");
if (x<=30 || y>=10)
	System.out.println("You're in trouble");

זוהי דוגמה פשוטה למדי - התנאי שלנו הוא שמשתנה מסוג int בשם x גדול מ-30 וגם משתנה מסוג int בשם y קטן מ-10 (כמובן, בהנחה ששני משתנים אלה כבר הוגדרו קודם). אם מתקיים אחד התנאים ההפוכים - x קטן או שווה ל-30 או y גדול או שווה ל-10 - ברור שהתנאי לא מתקיים. בדומה למרבית שפות התכנות, גם ג'אווה מציעה מנגנון שמקצר תהליך זה והופך אותו לפשוט יותר - מנגנון ה-else. קטע הקוד הבא שקול בדיוק לקטע שבתחילת הסעיף:

if (x>30 && y<10)
	System.out.println("It's OK");
else
	System.out.println("You're in trouble");

אם כך, בסופו של כל תנאי ניתן להוסיף else. אם התנאי לא מתקיים - יתקיים מה שכתוב בבלוק ה-else. ניתן להוסיף תנאים גם ל-else, אם כותבים else if (condition) במקום else בלבד. לתנאי else-if כזה ניתן להוסיף else משלו, או else-if משלו, וכך ניתן ליצור שרשרת של else-if. נציג כעת דוגמה לתוכנית שמשתמשת בשרשרת else-if ובתנאים מורכבים. בניגוד למנהגנו, נציג כאן תוכנית מלאה:

import java.util.Scanner;

public class GradeSystem {
	public static void main(String[] args) {
		Scanner s;
		s=new Scanner(System.in);
		int grade=s.nextInt();
		String str;
		if (grade>100 || grade<0)
			str="Illegal grade";
		else if (grade>=90)
			str="Very good";
		else if (grade>=80)
			str="Good";
		else if (grade>=70)
			str="Moderate";
		else if (grade>=60)
			str="Passed";
		else
			str="Failed";
		System.out.println(str);
	}
}

עכשיו תורכם: מה עושה התוכנית? מה מטרתה?

הערה: לכל תנאי ניתן להוסיף כמה else-if שרוצים. עם זאת, ניתן לכתוב else אחד בלבד (חשבו - מדוע?). else הוא אפשרות בלבד - אין חובה להשתמש בו, אך במקרים רבים הוא נוח מאוד.