אופרטורים

מה זה אופרטור?

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

אופרטורים אריתמטיים

אופרטור פעולה דוגמה
+ חיבור 5 + 3 = 8
- חיסור 5 - 3 = 2
* כפל 5 * 3 = 15
/ חילוק 10 / 3 = 3 (שלם!)
% מודולו (שארית) 10 % 3 = 1

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

int a = 10 / 3;        // 3 (לא 3.33!)
double b = 10 / 3;     // 3.0 (עדיין!)
double c = 10.0 / 3;   // 3.333...
double d = (double)10 / 3;  // 3.333...

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

מודולו - שימושים

// בדיקת זוגיות
if (n % 2 == 0) { /* זוגי */ }

// קבלת ספרת אחדות
int last = 123 % 10;   // 3

// מחזור על מערך
int index = i % array.length;

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

int a = 5;
a += 3;    // a = a + 3  →  8
a -= 2;    // a = a - 2  →  6
a *= 4;    // a = a * 4  →  24
a /= 2;    // a = a / 2  →  12
a %= 5;    // a = a % 5  →  2

אופרטורי הגדלה והקטנה

int a = 5;
a++;   // a = 6 (אחרי)
++a;   // a = 7 (לפני)
a--;   // a = 6
--a;   // a = 5

ההבדל בין a++ ל-++a

int a = 5;
int b = a++;   // b = 5, a = 6 (ההעלאה אחרי השימוש)

int c = 5;
int d = ++c;   // c = 6, d = 6 (ההעלאה לפני השימוש)

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

כולם מחזירים boolean:

אופרטור משמעות
== שווה
!= לא שווה
< קטן
> גדול
<= קטן או שווה
>= גדול או שווה
int a = 5, b = 10;
boolean isEqual = (a == b);     // false
boolean isSmaller = (a < b);    // true

זכרו: להשוואת מחרוזות השתמשו ב-.equals(), לא ב-==!

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

כל האופרטורים האלה עובדים על boolean ומחזירים boolean:

אופרטור משמעות שם
&& וגם AND
\|\| או OR
! לא NOT
boolean a = true, b = false;

a && b    // false - צריך ששניהם יהיו true
a || b    // true - מספיק שאחד יהיה true
!a        // false
!b        // true

short-circuit evaluation

if (x != 0 && 10 / x > 2) { }

כש-x == 0, Java לא מחשבת את החלק השני (לא מחלקת באפס). זה נקרא short-circuit.

אופרטור תנאי (טרנרי)

קיצור ל-if-else:

int age = 20;
String status = (age >= 18) ? "בוגר" : "קטין";

שקול ל:

String status;
if (age >= 18) {
    status = "בוגר";
} else {
    status = "קטין";
}

אופרטורים ביטיים

פועלים על הרמה הבינארית של המספרים:

אופרטור שם דוגמה
& AND ביטי 5 & 3 = 1
\| OR ביטי 5 \| 3 = 7
^ XOR ביטי 5 ^ 3 = 6
~ NOT ביטי ~5 = -6
<< הזזה שמאלה 5 << 1 = 10
>> הזזה ימינה 5 >> 1 = 2
int a = 5;           // 0101
int b = 3;           // 0011
int and = a & b;     // 0001 = 1
int or = a | b;      // 0111 = 7
int xor = a ^ b;     // 0110 = 6

שימושיים בעיקר לעבודה עם דגלים, פרוטוקולי רשת ומבני נתונים מתקדמים.

סדר קדימויות (מהגבוה לנמוך)

זו רשימה מקוצרת של האופרטורים הנפוצים בלבד. הטבלה המלאה של Java כוללת עוד רמות, למשל casting, האופרטורים הביטיים (&, |, ^, <<, >>) ו-instanceof.

  1. ++, --, ! (יוניאריים)
  2. *, /, %
  3. +, -
  4. <, <=, >, >=
  5. ==, !=
  6. &&
  7. ||
  8. ? : (טרנרי)
  9. =, +=, -= וכו'

עצה: בספק - השתמשו בסוגריים. זה קריא יותר.

int result = (a + b) * (c - d);   // ברור יותר

בדקו את עצמכם

נסו לענות לבד לפני שאתם פותחים את התשובה.

  1. מה התוצאה של 10 / 3 כששני המספרים int?

    1. 3.333
    2. 4
    3. 3
    4. שגיאה
    הצגת התשובה

    תשובה ג. חילוק של שני שלמים נותן תוצאה שלמה, והשארית נחתכת.

  2. מה התוצאה של 10 % 3?

    1. 3
    2. 0
    3. 3.33
    4. 1
    הצגת התשובה

    תשובה ד. % מחזיר את השארית של החילוק: 10 = 3*3 + 1.

  3. int a = 5; int b = a++; מה הערכים אחרי השורה?

    1. a=6, b=5
    2. a=5, b=6
    3. a=6, b=6
    4. a=5, b=5
    הצגת התשובה

    תשובה א. a++ מחזיר את הערך הישן (5) ורק אחר כך מגדיל את a ל-6.