אופרטורים ב-Java: חשבון, השוואה, לוגיקה והשמה

מה אופרטורים עושים

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

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

אופרטורים חשבוניים

חמשת האופרטורים החשבוניים פועלים על מספרים: +, -, *, / ו-% (שארית).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (חלוקת שלמים!)
        System.out.println(a % b);   // 2  (השארית)
    }
}

האופרטור % הוא השארית אחרי חלוקה: 17 % 5 הוא 2 כי 5 נכנס ב-17 שלוש פעמים ונשארים 2. זה הכלי היומיומי לבדיקת התחלקות: n % 2 == 0 היא הבדיקה המקובלת ל"האם n זוגי?".

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

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

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

המלכודת של חלוקת שלמים

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

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, לא 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (מספיק double אחד)
        System.out.println((double) 5 / 2); // 2.5 (המרה של אופרנד אחד)
    }
}

כדי לקבל תוצאה עשרונית, הפכו לפחות אופרנד אחד ל-double: או כתבו אותו עם .0, או המירו צד אחד עם (double). ההמרה (double)(5 / 2) לא עוזרת, כי חלוקת השלמים 5 / 2 כבר התבצעה לפני ההמרה; צריך להמיר אופרנד, לא את התוצאה.

אופרטורי השוואה

אופרטורי השוואה שואלים שאלת כן או לא ומחזירים boolean. יש שישה: ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

שימו לב להבדל בין = (השמה: "שים את הערך הזה כאן") לבין == (השוואה: "האם אלה שווים?"). בלבול ביניהם הוא באג קלאסי.

הסתייגות חשובה אחת: == משווה הפניות של אובייקטים, לא תוכן. במחרוזות, השתמשו ב-.equals().

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false: אובייקטים שונים
        System.out.println(a.equals(b));   // true: אותו טקסט
    }
}

השתמשו ב-== לטיפוסים פרימיטיביים כמו int ו-boolean, וב-.equals() בכל פעם שמשווים תוכן של אובייקטים כמו מחרוזות.

אופרטורים לוגיים

אופרטורים לוגיים משלבים ערכים בוליאניים: && (וגם), || (או) ו-! (לא). כך מבטאים תנאים כמו "מבוגר מספיק וגם יש לו כרטיס".

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& ו-|| מבצעים הערכה מקוצרת (short-circuit): Java מפסיקה לחשב ברגע שהתשובה ודאית. עם &&, אם האופרנד הראשון הוא false, השני לא נבדק בכלל; עם ||, אם האופרנד הראשון הוא true, השני מדולג. זה לא רק אופטימיזציה, אפשר לסמוך על זה לבטיחות:

if (text != null && text.length() > 0) { ... }

אם text הוא null, האופרנד הראשון הוא false ו-text.length() לא נקראת, וכך נמנעת NullPointerException. אם הופכים את הסדר, התוכנית קורסת.

השמה והגדלה

= משים, אבל ל-Java יש גם השמות מורכבות שמשלבות פעולה עם השמה: +=, -=, *=, /=, %=. ו-++ / -- מוסיפים או מחסירים אחד.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ מגיע בשתי גרסאות: postfix (count++) מחזיר את הערך הישן ואז מגדיל; prefix (++count) מגדיל קודם ואז מחזיר את הערך החדש. ההבדל חשוב רק כשמשתמשים בתוצאה באותו ביטוי:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // מדפיס 5, ואז x הופך ל-6
        System.out.println(++x);   // x הופך ל-7, מדפיס 7
    }
}

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

האופרטור הטרנרי

הטרנרי condition ? a : b הוא if/else קומפקטי שמפיק ערך: אם התנאי true הוא מחושב ל-a, אחרת ל-b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

הוא מצטיין בהשמות קצרות של או זה או זה. אל תקננו טרנרי בתוך טרנרי: זה נהיה לא קריא מהר מאוד, ו-if/else רגיל ברור יותר.

קדימות וסוגריים

אופרטורים מופעלים בסדר קבוע, בדומה למתמטיקה: *, /, % נקשרים חזק יותר מ-+ ו--, שנקשרים חזק יותר מהשוואות, שנקשרות חזק יותר מ-&&, ואחריו ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, לא 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

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

הבא: המרת טיפוסים

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