Evaluasi ekspresi Java dengan operator

Aplikasi Java memproses data dengan mengevaluasi ekspresi , yang merupakan kombinasi literal, pemanggilan metode, nama variabel, dan operator. Mengevaluasi ekspresi biasanya menghasilkan nilai baru, yang dapat disimpan dalam variabel, digunakan untuk membuat keputusan, dan sebagainya.

Dalam tutorial ini, Anda akan belajar bagaimana menulis ekspresi untuk program Java Anda. Dalam banyak kasus, Anda akan menggunakan operator untuk menulis ekspresi Java Anda, dan ada banyak tipe operator yang perlu diketahui cara menggunakannya. Saya akan secara singkat memperkenalkan tipe operator Java (termasuk tipe additive, bitwise, logical, conditional, shift, dan equality) dan operannya. Anda juga akan belajar tentang konsep penting seperti kelebihan beban operator dan prioritas operator, dan Anda akan melihat demonstrasi konversi tipe primitif. Saya akan menyimpulkan dengan program Java kecil yang dapat Anda gunakan untuk mempraktikkan konversi tipe primitif sendiri.

unduh Dapatkan kodenya Unduh kode sumber untuk aplikasi contoh dalam tutorial ini. Dibuat oleh Jeff Friesen untuk JavaWorld.

Ekspresi sederhana

Sebuah ungkapan sederhana adalah, nama variabel literal, atau metode panggilan. Tidak ada operator yang terlibat. Berikut beberapa contoh ekspresi sederhana:

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

Ekspresi sederhana memiliki tipe , yang merupakan tipe primitif atau tipe referensi. Dalam contoh ini, 52adalah 32-bit integer ( int); System.out.println("ABC");adalah void ( void) karena tidak mengembalikan nilai; "Java"adalah string ( String); 98.6Dadalah nilai floating-point presisi ganda 64-bit ( double); dan 89Lmerupakan integer panjang 64-bit ( long). Kami tidak tahu agetipenya.

Bereksperimen dengan jshell

Anda dapat dengan mudah mencoba ini dan ekspresi sederhana lainnya menggunakan jshell. Misalnya, masuk 52pada jshell>prompt dan Anda akan menerima sesuatu seperti output berikut:

$1 ==> 52

$1adalah nama variabel awal yang dibuat jshelluntuk disimpan 52. (Variabel awal dibuat setiap kali literal dimasukkan.) Jalankan System.out.println($1)dan Anda akan melihat 52hasilnya.

Anda bisa menjalankan jshelldengan -vargumen baris perintah ( jshell -v) untuk menghasilkan umpan balik verbose. Dalam kasus ini, memasukkan 52akan menghasilkan pesan berikut, mengungkapkan bahwa variabel awal $1memiliki inttipe (32-bit integer):

| created scratch variable $1 : int

Selanjutnya, coba masuk age. Dalam kasus ini, Anda mungkin akan menerima pesan kesalahan bahwa simbol tidak ditemukan. Java Shell menganggap itu ageadalah variabel, tetapi tidak mengetahui tipenya. Anda harus memasukkan tipe; misalnya, lihat apa yang terjadi jika Anda masuk int age.

Ekspresi majemuk

Sebuah ekspresi senyawa terdiri dari satu atau lebih sederhana ekspresi diintegrasikan ke dalam ekspresi yang lebih besar melalui Operator , yang merupakan urutan instruksi simbolis diwakili dalam kode sumber. Operator mengubah operan ekspresinya menjadi nilai lain. Misalnya, dalam 6 * 5, operator perkalian ( *) mengubah operan 6dan 5menjadi 30.

Ekspresi gabungan dapat digabungkan menjadi ekspresi yang lebih besar. Misalnya, 6 * 5 + 10menyajikan ekspresi majemuk 6 * 5dan ekspresi majemuk yang terdiri dari hasil kali, operator penjumlahan +, dan bilangannya 10. Urutan evaluasi (perkalian dulu lalu tambahkan) ditentukan oleh aturan prioritas Java , yang akan segera kita bahas.

Ekspresi gabungan juga bisa sederhana

6 * 5adalah ekspresi majemuk yang terdiri dari dua ekspresi sederhana, 6dan 5. Tapi 6 * 5juga ekspresi sederhana dari +sudut pandang. The +Operator hanya melihat produk mereka, 30, yang merupakan ekspresi sederhana.

Operator dan operan

Operator Java diklasifikasikan berdasarkan jumlah operannya:

  • Sebuah unary operator memiliki satu operan, misalnya dikurangi unary (misalnya, -5).
  • Sebuah operator biner memiliki dua operan, contoh adalah perkalian dan penambahan.
  • Sebuah operator ternary memiliki tiga operan; contohnya adalah operator kondisional ( ?:).

Operator Java juga diklasifikasikan berdasarkan posisi:

  • Sebuah Operator prefix adalah operator unary yang mendahului operan (misalnya, -5).
  • Sebuah Operator postfix adalah operator unary yang mengikuti operan (misalnya, age++;- tambahkan 1 ke agenilai numerik 's).
  • Sebuah Operator infiks adalah operator biner atau terner antara operan operator (misalnya, age + 5).

Contoh jshell lainnya

Saya akan memperkenalkan lebih banyak operator di bagian berikut, di mana saya menyajikan contoh dalam bentuk aplikasi. Anda juga dapat mencoba operator ini dengan jshell, seperti:

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

Dalam kasus ini, pertama-tama kita memasukkan ekspresi 6 + 2, yang jshellmengevaluasi, menetapkan variabel 8 ke awal yang dihasilkan $1. Selanjutnya, kita mengalikan $1dengan 7, yang menyimpan 56 dalam variabel awal $2. Contoh ini menunjukkan bahwa Anda dapat menggunakan variabel awal dalam ekspresi Java.

Operator yang kelebihan beban

Operator plus (+) adalah contoh operator yang kelebihan beban , yaitu operator yang melakukan salah satu dari beberapa operasi berdasarkan jenis operannya. Operator plus melakukan penambahan integer ketika kedua operan adalah integer, penambahan floating-point ketika kedua operan adalah nilai floating-point, dan penggabungan string ketika kedua operan adalah string. Operator minus (-) juga kelebihan beban, melakukan pengurangan integer atau floating-point.

Jenis operator di Java

Operator aditif

The operator aditif menambah atau mengurangi nilai numerik melalui penambahan dan pengurangan. Operator aditif termasuk penambahan ( +), pengurangan ( -), postdecrement ( --), postincrement ( ++), predecrement ( --), dan preincrement ( ++). String concatenation ( +) juga dianggap aditif. Berikut definisi formal untuk masing-masing operator ini:

  • Selain itu : Mengingat , di mana masing-masing operand harus karakter atau tipe numerik, tambahkan ke dan kembali jumlah tersebut. Contoh: .operand1 + operand2operand2operand14 + 6
  • Pengurangan : Diberikan , di mana setiap operan harus berupa karakter atau tipe numerik, kurangi dari dan kembalikan selisihnya. Contoh: .operand1 - operand2operand2operand14 - 6
  • Postdecrement: Given variable--, where variable must be of character or numeric type, subtract 1 from variable's value (storing the result in variable) and return the original value. Example: x--;.
  • Postincrement: Given variable++, where variable must be of character or numeric type, add 1 to variable's value (storing the result in variable) and return the original value. Example: x++;.
  • Predecrement: Given --variable, where variable must be of character or numeric type, subtract 1 from its value, store the result in variable, and return the new decremented value. Example: --x;.
  • Preincrement: Given ++variable, where variable must be of character or numeric type, add 1 to its value, store the result in variable, and return the new incremented value. Example: ++x;.
  • String concatenation: Given operand1 + operand2, where at least one operand is of String type, append operand2's string representation to operand1's string representation and return the result. Example: "A" + "B".

The addition, subtraction, postdecrement, postincrement, predecrement, and preincrement operators can generate values that overflow the limits of the result type. For example, adding two large positive 64-bit integer values can produce a value that cannot be represented in 64 bits. The resulting overflow is not detected or reported by Java's additive operators.

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.

Operator senyawa tugas ( +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=) mengevaluasi ekspresi dan menetapkan hasil untuk variabel dalam satu langkah. Setiap ekspresi dan variabel harus kompatibel dengan tugas. Setiap operator berfungsi sebagai jalan pintas yang berguna. Misalnya, daripada menentukan x = x + 3;, Anda bisa menentukan yang lebih pendek dan setara x += 3;.

Singkatnya!

Alih-alih menentukan x = x + 1;atau x = x - 1;, Anda dapat menentukan yang lebih pendek x += 1;atau x -= 1;. Anda dapat menyimpan lebih banyak lagi penekanan tombol dengan menentukan yang lebih pendek x++;atau x--;.

Operator bitwise