מפעילי תרכובות ג'אווה

1. סקירה כללית

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

נסביר גם כיצד הליהוק המרומז עובד.

2. מפעילי הקצאת מתחמים

אופרטור הקצאה הוא אופרטור בינארי המקצה את התוצאה של צד ימין למשתנה בצד שמאל. הפשוטה ביותר היא “=” מפעיל מטלה:

int x = 5;

הצהרה זו מכריזה על משתנה חדש איקס, מקצה איקס הערך של 5 וחוזר 5.

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

לדוגמא, שני משפטי הכפל הבאים שווים, כלומר א ו ב יהיה אותו ערך:

int a = 3, b = 3, c = -2; a = a * c; // מפעיל הקצאה פשוט b * = c; // מפעיל הקצאת מתחמים

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

כמו אופרטור ההקצאה "=", אופרטורים מורכבים מחזירים את התוצאה שהוקצתה של הביטוי:

ארוך x = 1; ארוך y = (x + = 2);

שניהם איקס ו y יחזיק את הערך 3.

המשימה (x + = 2) עושה שני דברים: ראשית, זה מוסיף 2 לערך המשתנה איקס, שהופך 3; שנית, הוא מחזיר את ערך המטלה, שהוא גם 3.

3. סוגי מפעילי הקצאת תרכובות

Java תומכת ב -11 מפעילי הקצאות מורכבות. אנו יכולים לקבץ אותם למפעילים אריתמטיים ומעט ביטים.

בוא נעבור על מפעילי החשבון והפעולות שהם מבצעים:

  • תוספת: +=
  • ירידה: -=
  • כֶּפֶל: *=
  • חֲלוּקָה: /=
  • מודולוס: %=

לאחר מכן, יש לנו גם המפעילים הסיבוניים:

  • AND, בינארי: &=
  • OR בלעדי, בינארי: ^=
  • OR כולל, בינארי: |=
  • משמרת שמאלה, בינארי: <<=
  • Shift ימני, בינארי: >>=
  • העבר מילוי אפס ימינה: >>>=

בואו נסתכל על כמה דוגמאות לפעולות אלה:

// הקצאה פשוטה int x = 5; // x הוא 5 // תוספת x + = 5; // x הוא 10 // ירידה x - = 2; // x הוא 8 // כפל x * = 2; // x הוא 16 // מודולוס x% = 3; // x הוא 1 // בינארי AND x & = 4; // x הוא 0 // בלעדי בינארי או x ^ = 4; // x הוא 4 // כולל בינארי או x | = 8; // x הוא 12

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

4. הערכת פעולות הקצאה מורכבות

ישנן שתי דרכים שג'אווה מעריכה את פעולות המתחם.

ראשון, כאשר האופרנד השמאלי אינו מערך, ואז ג'אווה, לפי הסדר:

  1. ודא שהאופראנד הוא משתנה מוצהר
  2. שמור את הערך של האופרנד השמאלי
  3. הערך את האופרנד הימני
  4. בצע את הפעולה הבינארית כפי שצוין על ידי מפעיל המתחם
  5. המיר את תוצאת הפעולה הבינארית לסוג המשתנה השמאלי (הליהוק משתמע)
  6. הקצה את התוצאה שהומר למשתנה השמאלי

הַבָּא, כאשר האופרנד השמאלי הוא מערך, השלבים שיש לבצע הם מעט שונים:

  1. אמת את ביטוי המערך בצד שמאל והשליך א NullPointerException אוֹ אינדקס מערך מחוץ לתחום Exception אם זה לא נכון
  2. שמור את אלמנט המערך באינדקס
  3. הערך את האופרנד הימני
  4. בדוק אם רכיב המערך שנבחר הוא סוג פרימיטיבי או סוג הפניה ואז המשך באותן שלבים כמו הרשימה הראשונה, כאילו האופראן השמאלי הוא משתנה.

אם שלב כלשהו בהערכה נכשל, ג'אווה לא ממשיכה לבצע את השלבים הבאים.

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

int [] numbers = null; // מנסים מספרי תוספת [2] + = 5;

כפי שהיינו מצפים, זה יזרוק א NullPointerException.

עם זאת, אם אנו מקצים ערך ראשוני למערך:

int [] numbers = {0, 1}; // מנסים מספרי תוספת [2] + = 5;

היינו נפטרים מה- NullPointerException, אבל עדיין היינו מקבלים אינדקס מערך מחוץ לתחום Exception, מכיוון שהאינדקס בו נעשה שימוש אינו נכון.

אם נתקן זאת, הפעולה תושלם בהצלחה:

int [] numbers = {0, 1}; // מספרי תוספות [1] + = 5; // x עכשיו 6

סוף - סוף, ה איקס משתנה יהיה 6 בתום המטלה.

5. ליהוק משתמע

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

באופן רשמי, ביטוי להקצאה מורכבת של הטופס:

E1 op = E2

שווה ל:

E1 - (T) (E1 op E2)

איפה ט הוא סוג של E1.

בואו ניקח בחשבון את הדוגמה הבאה:

מספר ארוך = 10; int i = מספר; i = i * מספר; // לא מהדר

בואו נסקור מדוע השורה האחרונה לא תיאסף.

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

אז ראשית, אני יקודם ל ארוך ואז הכפל ייתן את התוצאה 10 ליטר. התוצאה הארוכה תוקצה ל אני, שהוא int, וזה יזרוק שגיאה.

ניתן לתקן זאת באמצעות צוות שחקנים מפורש:

i = (int) i * מספר;

מפעילי הקצאת תרכובות ג'אווה מושלמים במקרה זה מכיוון שהם עושים ליהוק מרומז:

i * = מספר;

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

6. מסקנה

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

לבסוף, סקרנו גם ליהוק משתמע, אחת הסיבות שמפעילים קצרים אלה שימושיים.

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


$config[zx-auto] not found$config[zx-overlay] not found