הערך ביטויים של Java עם אופרטורים

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

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

הורד קבל את הקוד הורד את קוד המקור למשל יישומים במדריך זה. נוצר על ידי ג'ף פרייזן עבור JavaWorld.

ביטויים פשוטים

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

52 // integer literal age // variable name System.out.println("ABC"); // method call "Java" // string literal 98.6D // double precision floating-point literal 89L // long integer literal

לביטוי פשוט יש סוג שהוא סוג פרימיטיבי או סוג ייחוס. בדוגמאות אלה, 52הוא מספר שלם של 32 סיביות ( int); System.out.println("ABC");בטל ( void) מכיוון שהוא אינו מחזיר ערך; "Java"הוא מחרוזת ( String); 98.6Dהוא ערך נקודה צפה כפול של 64 סיביות ( double); והוא 89Lמספר שלם של 64 סיביות ( long). אנחנו לא יודעים ageמה הסוג.

מתנסים עם jshell

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

$1 ==> 52

$1השם הוא של משתנה מאפס כי jshellיוצר לאחסון 52. (משתני שריטה נוצרים בכל פעם שמזינים ליטרלים.) בצע System.out.println($1)ותראה 52כפלט.

אתה יכול לרוץ jshellעם -vהארגומנט של שורת הפקודה ( jshell -v) כדי ליצור משוב רב. במקרה זה, הזנה 52תביא להודעה הבאה, ותגלה שמשתנה שריטה $1הוא intבעל סוג שלם (32 סיביות):

| created scratch variable $1 : int

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

ביטויים מורכבים

ביטוי מתחם מורכב ביטויים אחת או יותר פשוט להשתלב ביטוי גדול יותר באמצעות מפעיל , המהווה רצף של הוראות מיוצגות באופן סמלי בקוד מקור. המפעיל הופך את אופרנד (ים) הביטוי שלו לערך אחר. לדוגמא, ב 6 * 5, מפעיל הכפל ( *) תמרות operands 6ו 5לתוך 30.

ניתן לשלב ביטויים מורכבים לביטויים גדולים יותר. לדוגמה, 6 * 5 + 10מציג ביטוי 6 * 5מורכב וביטוי מורכב המורכב מהמוצר שלהם, מפעיל התוספת +והמספר 10. סדר ההערכה (הכפל תחילה ואז הוסף) מוכתב על ידי כלל הקדימות של ג'אווה , אליו נגיע בקרוב.

גם ביטויים מורכבים יכולים להיות פשוטים

6 * 5הוא ביטוי מורכב המורכב משני ביטויים פשוטים, 6ו 5. אך 6 * 5הוא גם ביטוי פשוט +מנקודת מבטו. +המפעיל רואה רק את המוצר שלהם, 30, המהווה ביטוי פשוט.

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

מפעילי ג'אווה מסווגים לפי מספר האופנדים שלהם:

  • מפעילת יונארית יש האופרנד אחד, למשל מינוס אונרי (למשל, -5).
  • מפעיל בינארי יש שני האופרנדים, הדוגמאות הן כפל בנוסף.
  • מפעילה משולשת יש שלושה אופרנדים; דוגמה היא המפעיל המותנה ( ?:).

מפעילי Java מסווגים גם לפי מיקום:

  • מפעילת קידומת הוא מפעיל יונארית שקודם האופרנד שלה (למשל, -5).
  • אופרטור פוסט- תיקון הוא אופרטור שאינו עוקב אחרי האופראנד שלו (למשל age++;- הוסף ערך אחד למספר ageהמספרי).
  • מפעילת Infix הוא מפעיל בינארי או משולשת בין האופרנדים של המפעיל (למשל, age + 5).

דוגמא נוספת ל jshell

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

jshell> 6 + 2 $1 ==> 8 jshell> 7 * $1 $2 ==> 56

במקרה זה, אנו נכנסים תחילה לביטוי 6 + 2, jshellהמעריך, ולהקצות את המשתנה המתקבל 8 לשרוט $1. הבא, נכפיל $1ידי 7, אשר מאחסן 56 ב משתנה מאפס $2. דוגמה זו מדגימה כי ניתן להשתמש במשתני שריטה בביטויי Java.

מפעילים עמוסים מדי

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

סוגי מפעילים בג'אווה

מפעילים תוספים

מפעילי התוסף להגדיל או להקטין ערך מספרים באמצעות חיבור וחיסור. אופרטורים תוספים כוללים חיבור ( +), חיסור ( -), postdecrement ( --), postincrement ( ++), predecrement ( --), ו- preincrement ( ++). שרשור מחרוזות ( +) נחשב גם כתוסף. להלן הגדרה רשמית לכל אחד מהמפעילים הבאים:

  • תוספת : בהינתן , כאשר כל האופרנד חייב להיות בעל אופי או סוג מספריים, להוסיף כדי ולהחזיר את הסכום. דוגמה: .operand1 + operand2operand2operand14 + 6
  • חיסור : בהינתן , כאשר כל האופרנד חייב להיות בעל אופי או סוג מספריים, לחסר מן ולהחזיר את ההבדל. דוגמה: .operand1 - operand2operand2operand14 - 6
  • לאחר ירידה : נתון variable--, היכן variableשצריך להיות בעל אופי או סוג מספרי, גרע 1 variableמערכו (אחסן את התוצאה variable) והחזיר את הערך המקורי. דוגמה: x--;.
  • Postincrement : נתון variable++, היכן variableשחייב להיות מסוג אופי או מספרי, הוסף variableערך לערך 1 (אחסן את התוצאה variable) והחזיר את הערך המקורי. דוגמה: x++;.
  • הקדמה מראש : בהתחשב במקום בו חייבת להיות סוג או מספר מספרי, גורע 1 מערכו, אחסן את התוצאה בה והחזיר את הערך המופחת החדש. דוגמה: .--variablevariablevariable--x;
  • עלייה מוקדמת : נתון , היכן שצריך להיות בעל אופי או סוג מספרי, הוסף ערך אחד שלו, אחסן את התוצאה והחזיר את הערך המצטבר החדש. דוגמה: .++variablevariablevariable++x;
  • שרשור מחרוזות : נתון , כאשר לפחות אופרנד אחד הוא מסוגו, צרף את ייצוג המחרוזות לייצוג המחרוזות והחזיר את התוצאה. דוגמה: .operand1 + operand2Stringoperand2operand1"A" + "B"

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

Overflow detection in the Java standard class library

The standard class library's Math class includes methods for detecting overflows. For example, int addExact(int x, int y) adds the values in x and y, returning the sum or throwing an exception on overflow.

Example application: Additive operators

Listing 1 presents a small application for playing with Java's additive operators.

Listing 1. Additive operators in Java (AddOp.java)

class AddOp { public static void main(String[] args) { System.out.println(125 + 463); System.out.println(2.0 - 6.3); int age = 65; System.out.println(age); System.out.println(age--); System.out.println(age++); System.out.println(--age); System.out.println(++age); System.out.println("A" + "B"); } }

You learned in the previous tutorial how to use the JDK's javac tool to compile Java source code and the java tool to run the resulting application. Execute the following command to compile Listing 1:

javac AddOp.java

Assuming successful compilation, you should observe an AddOp.class file in the current directory. Execute the following command to run it:

java AddOp

AddOp responds by producing the following output:

588 -4.3 65 65 64 64 65 AB

Studying this output offers insight into the postincrement, postdecrement, preincrement, and predecrement operators. For postincrement/postdecrement, age's current value is output before the increment/decrement operation. For preincrement/predecrement, the operation is performed and its result is stored in age, and then age's new value is output.

Iterating with Java operators

The additive operators are especially useful in the context of an iteration statement, where they are used to advance to the next iteration. You'll learn about iteration statements in the next Java 101 tutorial.

Array index operator

The array index operator ([]) accesses an array element by providing the element's index (position). This operator is placed after the array variable's name, as in grades[0] (access the first element in the array assigned to grades; the first element is stored at index 0). Here's a formal definition:

Given variable[index], where index must be of integer (int) type, read a value from or store a value into variable's storage element at location index. Example: temperatures[1]

The value passed to index is a 32-bit integer that is either 0 or a positive value ranging to one less than the array's length, which is indicated by appending .length to the name of the array. For example, grades.length returns the number of elements in the array assigned to grades.

Array variables vs arrays

grades is not an array, but is a variable containing a reference to a region of memory that forms the array. This is true for all Java arrays. However, it's conventional to refer to grades or any array variable as an array.

Example application: Array index operator

Listing 2 presents the source code to an example application that lets you play with the array index operator.

Listing 2. Array index operator in Java (ArrayIndexOp.java)

class ArrayIndexOp { public static void main(String[] args) { int[] grades = { 89, 90, 68, 73, 79 }; System.out.println(grades[1]); grades[1] = 91; System.out.println(grades[1]); int index = 4; System.out.println(grades[index]); System.out.println(grades['C' - 'A']); // System.out.println(grades[1D]); } }

Listing 2 is somewhat more interesting than Listing 1. After creating a five-element, one-dimensional array of integers (via an array initializer) and assigning the array's reference to grades, main() proceeds to access various elements. Two items are of special interest:

  • The array index operator's index must ultimately be a 32-bit integer (0 or a positive value). You can specify the name of an integer variable (e.g., index), which contains the index value, as the index.
  • You can specify a calculation involving character literals. (Later in this tutorial I'll introduce type conversions, and you'll discover why 'C' - 'A' produces an integer (2), which serves as a valid index.)

The final example, which passes 1D as an index to the array index operator, is commented out because it will not compile. If you uncomment the line and attempt to compile Listing 2, you will receive an error message about incompatible types: "possible lossy conversion from double to int.."

Compile Listing 2 (javac ArrayIndexOp.java) and run the application (java ArrayIndexOp). You should observe the following output:

90 91 79 68

The array index operator and multidimensional arrays

You can use this operator with multidimensional arrays. For example, assuming a two-dimensional costs array, costs[0][1] accesses the element assigned to the first row (via [0]) and the second column (via [1]).

Assignment operators

The assignment operator (=) assigns an expression's value to a variable (e.g., i = 6;), including an array element (e.g., x[0] = 15;). The expression and variable must be assignment compatible, meaning their types must agree. For example, you cannot assign a string literal to an integer variable. I'll explain more about this when we discuss type conversions.

מפעילי הקצאה מתחם ( +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=) להעריך ביטויים ולהקצות את התוצאות משתנים בצעד אחד. כל ביטוי ומשתנה חייבים להיות תואמים למשימה. כל מפעיל משמש כקיצור דרך שימושי. לדוגמה, במקום לציין x = x + 3;, אתה יכול לציין את הקצר והמקביל x += 3;.

לשמור את זה קצר!

במקום לציין x = x + 1;או x = x - 1;, תוכל לציין את הקצר x += 1;או x -= 1;. אתה יכול לשמור עוד הקשות על ידי ציון הקצר x++;או x--;.

מפעילים סיביות