Pengendali Kompaun Java

1. Gambaran keseluruhan

Dalam tutorial ini, kita akan melihat pengendali kompaun Java, jenisnya dan bagaimana Java menilai mereka.

Kami juga akan menerangkan bagaimana pemutus tersirat berfungsi.

2. Pengendali Tugasan Kompaun

Pengendali tugasan adalah pengendali binari yang memberikan hasil dari sisi kanan ke pemboleh ubah di sebelah kiri. Yang paling mudah ialah pengendali tugasan “=” :

int x = 5;

Pernyataan ini menyatakan pemboleh ubah baru x , memberikan x nilai 5 dan mengembalikan 5 .

Pengendali Tugasan Kompaun adalah cara yang lebih pendek untuk menerapkan operasi aritmetik atau bitwise dan memberikan nilai operasi kepada pemboleh ubah di sebelah kiri.

Sebagai contoh, dua pernyataan pendaraban berikut adalah setara, yang bermaksud a dan b akan mempunyai nilai yang sama:

int a = 3, b = 3, c = -2; a = a * c; // Simple assignment operator b *= c; // Compound assignment operator

Penting untuk diperhatikan bahawa pemboleh ubah di sebelah kiri pengendali penugasan kompaun mesti sudah dinyatakan. Dengan kata lain, pengendali kompaun tidak boleh digunakan untuk menyatakan pemboleh ubah baru.

Seperti pengendali tugasan “=”, pengendali kompaun mengembalikan hasil ungkapan yang diberikan:

long x = 1; long y = (x+=2);

Kedua-dua x dan y akan memegang nilai 3 .

Tugasan (x + = 2) melakukan dua perkara: pertama, ia menambah 2 pada nilai pemboleh ubah x , yang menjadi 3; kedua, ia mengembalikan nilai tugasan, yang juga 3 .

3. Jenis Pengendali Tugasan Kompaun

Java menyokong 11 pengendali penugasan kompaun. Kami boleh mengumpulkannya menjadi operator aritmetik dan bitwise.

Mari kita teliti pengendali aritmetik dan operasi yang mereka lakukan:

  • Penambahan: + =
  • Penurunan: - =
  • Pendaraban: * =
  • Bahagian: / =
  • Modulus: % =

Kemudian, kami juga mempunyai pengendali bitwise:

  • DAN, binari: & =
  • Eksklusif ATAU, binari: ^ =
  • Inklusif ATAU, binari: | =
  • Shift Kiri, binari: << =
  • Shift Kanan, binari: >> =
  • Geser ke kanan sifar isian: >>> =

Mari kita lihat beberapa contoh operasi ini:

// Simple assignment int x = 5; // x is 5 // Incrementation x += 5; // x is 10 // Decrementation x -= 2; // x is 8 // Multiplication x *= 2; // x is 16 // Modulus x %= 3; // x is 1 // Binary AND x &= 4; // x is 0 // Binary exclusive OR x ^= 4; // x is 4 // Binary inclusive OR x |= 8; // x is 12

Seperti yang kita lihat di sini, sintaks untuk menggunakan operator ini adalah konsisten.

4. Penilaian Operasi Penugasan Kompaun

Terdapat dua cara Java menilai operasi kompaun.

Pertama, apabila operan sebelah kiri bukan array, maka Java akan, dengan urutan:

  1. Sahkan operan adalah pemboleh ubah yang dinyatakan
  2. Simpan nilai operan sebelah kiri
  3. Nilaikan operan sebelah kanan
  4. Lakukan operasi binari seperti yang ditunjukkan oleh pengendali kompaun
  5. Tukarkan hasil operasi binari ke jenis pemboleh ubah sebelah kiri (casting tersirat)
  6. Berikan hasil yang ditukar ke pemboleh ubah sebelah kiri

Seterusnya, apabila operan kiri adalah tatasusunan, langkah-langkah yang harus diikuti adalah sedikit berbeza:

  1. Sahkan ungkapan array di sebelah kiri dan lemparkan NullPointerException atau ArrayIndexOutOfBoundsException jika tidak betul
  2. Simpan elemen array dalam indeks
  3. Nilaikan operan sebelah kanan
  4. Periksa sama ada komponen larik yang dipilih adalah jenis primitif atau jenis rujukan dan kemudian teruskan dengan langkah yang sama dengan senarai pertama, seolah-olah operan sebelah kiri adalah pemboleh ubah.

Sekiranya ada langkah penilaian gagal, Java tidak terus melakukan langkah-langkah berikut.

Mari berikan beberapa contoh yang berkaitan dengan penilaian operasi ini ke elemen array:

int[] numbers = null; // Trying Incrementation numbers[2] += 5;

Seperti yang kita jangkakan, ini akan menimbulkan NullPointerException .

Walau bagaimanapun, jika kita memberikan nilai awal untuk array:

int[] numbers = {0, 1}; // Trying Incrementation numbers[2] += 5;

Kami akan menyingkirkan NullPointerException, tetapi kami masih mendapat ArrayIndexOutOfBoundsException , kerana indeks yang digunakan tidak betul.

Sekiranya kami memperbaikinya, operasi akan berjaya diselesaikan:

int[] numbers = {0, 1}; // Incrementation numbers[1] += 5; // x is now 6

Akhirnya, pemboleh ubah x akan menjadi 6 pada akhir tugasan.

5. Casting Tersirat

Salah satu sebab pengendali kompaun berguna adalah bahawa bukan sahaja mereka menyediakan cara yang lebih pendek untuk operasi, tetapi juga secara implisit membuang pemboleh ubah.

Secara rasmi, ungkapan penugasan kompaun bentuk:

E1 op = E2

bersamaan dengan:

E1 - (T) (E1 op E2)

di mana T adalah jenis E1 .

Let’s consider the following example:

long number = 10; int i = number; i = i * number; // Does not compile

Let’s review why the last line won’t compile.

Java automatically promotes smaller data types to larger data ones, when they are together in an operation, but will throw an error when trying to convert from larger to smaller types.

So, first, i will be promoted to long and then the multiplication will give the result 10L. The long result would be assigned to i, which is an int, and this will throw an error.

This could be fixed with an explicit cast:

i = (int) i * number;

Java compound assignment operators are perfect in this case because they do an implicit casting:

i *= number;

Pernyataan ini berfungsi dengan baik, memberikan hasil pendaraban ke int dan memberikan nilai ke pemboleh ubah sebelah kiri, i .

6. Kesimpulannya

Dalam artikel ini, kami melihat operator kompaun di Jawa, memberikan beberapa contoh dan pelbagai jenisnya. Kami menerangkan bagaimana Java menilai operasi ini.

Akhirnya, kami juga mengkaji pemutus tersirat, salah satu sebab pengendali ringkas ini berguna.

Seperti biasa, semua coretan kod yang disebutkan dalam artikel ini terdapat di repositori GitHub kami.