Nilaikan ungkapan Java dengan operator

Aplikasi Java memproses data dengan menilai ekspresi , yang merupakan kombinasi literal, panggilan metode, nama berubah-ubah, dan operator. Menilai ekspresi biasanya menghasilkan nilai baru, yang dapat disimpan dalam pemboleh ubah, digunakan untuk membuat keputusan, dan sebagainya.

Dalam tutorial ini, anda akan belajar bagaimana menulis ungkapan untuk program Java anda. Dalam banyak kes, anda akan menggunakan operator untuk menulis ungkapan Java anda, dan terdapat banyak jenis operator yang tahu bagaimana menggunakannya. Saya akan memperkenalkan secara ringkas jenis operator Java (termasuk jenis aditif, bitwise, logik, bersyarat, pergeseran, dan persamaan) dan operan mereka. Anda juga akan belajar mengenai konsep penting seperti kelebihan operator dan keutamaan operator, dan anda akan melihat demonstrasi penukaran jenis primitif. Saya akan menyimpulkan dengan program Java kecil yang boleh anda gunakan untuk mempraktikkan penukaran jenis primitif sendiri.

muat turun Dapatkan kod Muat turun kod sumber misalnya aplikasi dalam tutorial ini. Dicipta oleh Jeff Friesen untuk JavaWorld.

Ungkapan ringkas

A ungkapan mudah ialah literal, nama boleh ubah, atau kaedah panggilan. Tidak ada operator yang terlibat. Berikut adalah beberapa contoh ungkapan 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

Ungkapan sederhana mempunyai jenis , iaitu jenis primitif atau jenis rujukan. Dalam contoh ini, 52adalah bilangan bulat 32-bit ( int); System.out.println("ABC");tidak sah ( void) kerana tidak mengembalikan nilai; "Java"ialah rentetan ( String); 98.6Dadalah nilai titik apungan ketepatan berganda 64-bit ( double); dan 89Ladalah bilangan bulat panjang 64-bit ( long). Kami tidak tahu agejenisnya.

Mengeksperimen dengan jshell

Anda boleh mencuba ungkapan-ungkapan sederhana dan lain-lain dengan mudah jshell. Contohnya, masukkan 52pada arahan jshell>dan anda akan menerima seperti output berikut:

$1 ==> 52

$1adalah nama pemboleh ubah calar yang jshellmencipta untuk menyimpan 52. (Pemboleh ubah calar dibuat setiap kali literal dimasukkan.) Jalankan System.out.println($1)dan anda akan melihat 52sebagai output.

Anda boleh menjalankan jshelldengan -vargumen baris perintah ( jshell -v) untuk menghasilkan maklum balas verbose. Dalam hal ini, memasukkan 52akan menghasilkan pesan berikut, yang menunjukkan bahawa pemboleh ubah calar $1mempunyai jenis int(bilangan bulat 32-bit):

| created scratch variable $1 : int

Seterusnya, cuba masukkan age. Dalam kes ini, anda mungkin akan menerima mesej ralat bahawa simbol itu tidak dijumpai. Java Shell menganggap itu agepemboleh ubah, tetapi tidak tahu jenisnya. Anda mesti memasukkan jenis; sebagai contoh, lihat apa yang berlaku sekiranya anda memasukkan int age.

Ungkapan majmuk

A ungkapan sebatian terdiri daripada satu atau lebih mudah ungkapan bersepadu ke dalam ungkapan yang lebih besar melalui operator , yang merupakan urutan arahan secara simbolik diwakili dalam kod sumber. Pengendali mengubah operan ekspresinya menjadi nilai lain. Sebagai contoh, di 6 * 5, operator pendaraban ( *) mengubah operand 6dan 5menjadi 30.

Ungkapan majmuk dapat digabungkan menjadi ungkapan yang lebih besar. Contohnya, 6 * 5 + 10menunjukkan ungkapan majmuk 6 * 5dan ungkapan majmuk yang terdiri daripada produk mereka, operator penambahan +, dan bilangannya 10. Urutan penilaian (darabkan pertama dan kemudian tambahkan) ditentukan oleh peraturan keutamaan Java , yang akan kita sampaikan sebentar lagi.

Ungkapan majmuk juga mudah

6 * 5adalah ungkapan majmuk yang terdiri daripada dua ungkapan sederhana, 6dan 5. Tetapi 6 * 5juga merupakan ungkapan sederhana dari +perspektif. The +pengendali hanya melihat produk mereka, 30, yang merupakan ungkapan yang mudah.

Pengendali dan operasi

Pengendali Java dikelaskan berdasarkan jumlah operasi mereka:

  • A operator unari mempunyai satu operan, sebagai contoh tolak unari (contohnya, -5).
  • A operator binari mempunyai dua operan, contoh adalah pendaraban dan tambahan.
  • A pengendali pertigaan mempunyai tiga operan; contohnya ialah pengendali bersyarat ( ?:).

Operator Java juga dikelaskan berdasarkan kedudukan:

  • A pengendali awalan adalah pengendali unari yang mendahului operan (contohnya, -5).
  • A operator postfix adalah pengendali unari yang berikut operan (contohnya, age++;- menambah 1 untuk agenilai angka 's).
  • An pengendali infiks adalah pengendali binari atau pertigaan antara operan operator (contohnya, age + 5).

Contoh lain jshell

Saya akan memperkenalkan lebih banyak pengendali dalam bahagian berikut, di mana saya memberikan contoh dalam bentuk aplikasi. Anda juga boleh mencuba pengendali ini dengan jshell, seperti:

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

Dalam kes ini, pertama kali kita memasukkan ungkapan 6 + 2, yang jshellmenilai, menetapkan pemboleh ubah 8 hingga calar yang dihasilkan $1. Seterusnya, kita mengalikan $1dengan 7, yang menyimpan 56 dalam pemboleh ubah calar $2. Contoh ini menunjukkan bahawa anda boleh menggunakan pemboleh ubah calar dalam ekspresi Java.

Pengendali yang terlalu banyak

Operator tambah (+) adalah contoh pengendali yang terlalu banyak , yang merupakan pengendali yang melakukan salah satu daripada beberapa operasi berdasarkan jenis operannya. Pengendali tambah melakukan penambahan integer apabila kedua-dua operan adalah bilangan bulat, penambahan titik terapung ketika kedua-dua operan adalah nilai titik terapung, dan gabungan tali ketika kedua-dua operan adalah rentetan. Pengendali tolak (-) juga berlebihan, melakukan pengurangan integer atau floating-point.

Jenis operator di Java

Pengendali bahan tambah

The pengendali tambahan menambah atau mengurangkan nilai angka melalui penambahan dan penolakan. Pengendali aditif merangkumi penambahan ( +), pengurangan ( -), postdecrement ( --), postincrement ( ++), predecrement ( --), dan preincrement ( ++). Gabungan tali ( +) juga dianggap sebagai bahan tambah. Berikut adalah definisi rasmi untuk setiap pengendali ini:

  • Addition : Memandangkan , di mana setiap operan perlu menjadi watak atau jenis angka, tambah ke dan kembali jumlah. Contoh : .operand1 + operand2operand2operand14 + 6
  • Pengurangan : Diberi , di mana setiap operan mestilah jenis watak atau angka, tolak dari dan kembalikan perbezaannya. 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.

Pengendali tugasan kompaun ( +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=) menilai ungkapan dan memberikan keputusan kepada pembolehubah dalam satu langkah. Setiap ungkapan dan pemboleh ubah mesti sesuai dengan tugasan. Setiap pengendali berfungsi sebagai jalan pintas yang berguna. Sebagai contoh, daripada menentukan x = x + 3;, anda boleh menentukan yang lebih pendek dan setara x += 3;.

Kekal!

Daripada menentukan x = x + 1;atau x = x - 1;, anda boleh menentukan yang lebih pendek x += 1;atau x -= 1;. Anda dapat menyimpan lebih banyak lagi ketukan kekunci dengan menentukan yang lebih pendek x++;atau x--;.

Pengendali bitwise