אופרטורים מספריים ב-Java

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

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

פלט מסוף: 1032 966 32967 30 כבר השתמשת בכל זה. לקבוצה זו, אתה יכול להוסיף לאופרטור השאר או מודולו ( %).

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

פלט מסוף: 1 בדוגמה זו, אנו מחלקים 33 ב-2. זה מניב 16, עם "זנב" נוסף (אחד) שאינו מתחלק ב-2. "זנב" זה הוא תוצאה של פעולת "השאר מחלוקה". Java גם מיישמת אופרטורים של השוואה/יחסים (בדיוק כמו במתמטיקה). הם בטח מוכרים לך גם מבית הספר:

• שווה ל ( ==)
• גדול מ ( >)
• פחות מ ( <)
• גדול מ או שווה ל ( >=)
• פחות מ או שווה ל ( <=)
• לא שווה ( !=)

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

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

פלט קונסולה: 999 אופס! זו כמובן לא התוצאה שציפינו לה. זה סוג נתונים אחר לגמרי: ציפינו לראות ערך בוליאני , אבל קיבלנו מספר. הכל בגלל שהשתמשנו באופרטור הקצאה בסוגריים במקום בהשוואה . x=y הערך של y(999) הוקצה למשתנה xולאחר מכן הצגנו את הערך של x. הנה הדרך הנכונה לעשות זאת:

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

פלט מסוף: false כעת השווינו את שני המספרים כראוי! :) הנה תכונה נוספת של אופרטור ההקצאה ( =): ניתן "לשרשר" אותו יחד:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

פלט מסוף: 256 זכור שההקצאה היא מימין לשמאל . ביטוי זה ( x = y = z) יבוצע בשלבים:

• y = z, זה,y = 256
• x = y, זה,x = 256

מפעילים אונריים.

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

• מינוס לא נורמלי. זה הופך את סימן המספר.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

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

• הגדלה (++) והקטנה (--)

המפעיל ++מגדיל מספר באחד, והמפעיל --מקטין מספר באותה כמות.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

פלט מסוף: 1000 999 סימון זה עשוי להיות מוכר לך אם שמעתם על שפת C++. יוצריו השתמשו בשם המעניין הזה כדי להעביר את הרעיון ש"C++ היא הרחבה של שפת C" גרסה משופרת פופולרית של Notepad נקראת Notepad++ הנה נקודה חשובה. ישנם שני סוגים של אופרטורים לתוספת והפחתה : postfix וקידומת . - postfix - prefix מה ההבדל המהותי בין הצבת הפלוסים/מינוסים לפני או אחרי המספר? נראה בדוגמה הבאה: x++++x

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

פלט קונסולה: 999 משהו לא בסדר! רצינו להגדיל xב-1 ולהקצות את הערך החדש למשתנה y. במילים אחרות, y צריך להיות 1000. אבל במקום זאת נקבל משהו אחר: 999. נראה כאילו x לא הוגדל ושהאופרטור ההגדלה לא עבד? אבל זה כן עבד. כדי לשכנע את עצמך, נסה להציג xבסוף :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

פלט מסוף: 999 1000 למעשה, זו בדיוק הסיבה שהפעולה הזו נקראת postfix: היא מבוצעת אחרי הביטוי הראשי. זה אומר, במקרה שלנו: int y = x++; y = xמתבצע קודם (והמשתנה yיאתחל לערך של x), ורק לאחר מכן יתבצע x++מה אם זו לא ההתנהגות שאנחנו רוצים? אז אנחנו צריכים להשתמש בסימון קידומת :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

במקרה זה, ++xמעובד תחילה ורק לאחר מכן הוא y = x; יצא לפועל. עליך להקדיש את ההבדל הזה לזיכרון מיד כדי להימנע מטעויות בתוכנית אמיתית שבה שימוש בקידומת postfix יכול להפוך הכל על הפוך :)

מפעילי מתחם

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

• מְשִׁימָה
• אופרטורים אריתמטיים

אלו כוללים:

• +=
• -=
• *=
• /=
• %=

הבה נשקול דוגמה:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

פלט מסוף: 1032 x += y פירושו x = x + y. שני הסמלים משמשים ברציפות למען הקיצור. השילובים -=, *=, /=ועובדים %=בצורה דומה.

פעולות לוגיות

בנוסף לאופרטורים מספריים, ל-Java יש גם פעולות הכוללות ערכים בוליאניים ( true and false ). פעולות אלו מבוצעות באמצעות אופרטורים לוגיים

• !- הגיוני לא . זה הופך את הערך של בוליאני

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

פלט מסוף: שקר

• &&- AND הגיוני . הוא מחזיר אמת רק אם שני האופרנדים נכונים.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

פלט מסוף: false true התוצאה של הפעולה הראשונה היא false, מכיוון שאחד מהאופרנדים הוא false, כלומר 100 > 200. כדי להחזיר אמת, &&האופרטור דורש ששני האופרנדים יהיו אמיתיים (כפי שקורה בשורה השנייה).

• ||- OR הגיוני . הוא מחזיר אמת כאשר לפחות אחד מהאופרנדים הוא אמת.

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

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

פלט מסוף: true הביטוי 100 > 200עדיין לא נכון, אבל עבור האופרטור OR זה מספיק לחלוטין שהחלק הראשון ( 100 > 10) יהיה נכון.