Java сложни оператори

1. Общ преглед

В този урок ще разгледаме съставните оператори на Java, техните типове и как ги оценява Java.

Също така ще обясним как работи неявното кастинг.

2. Сложни оператори за присвояване

Операторът за присвояване е двоичен оператор, който присвоява резултата от дясната страна на променливата от лявата страна. Най-простият е операторът за присвояване „=” :

int x = 5;

Този оператор декларира нова променлива x , присвоява x стойността 5 и връща 5 .

Сложните оператори за присвояване са по-кратък начин за прилагане на аритметична или битова операция и за присвояване на стойността на операцията на променливата отляво.

Например, следните два оператора за умножение са еквивалентни, което означава, че a и b ще имат една и съща стойност:

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

Важно е да се отбележи, че променливата отляво на съставен оператор за присвояване трябва вече да е декларирана. С други думи, съставните оператори не могат да се използват за деклариране на нова променлива.

Подобно на оператора за присвояване “=”, съставните оператори връщат присвоения резултат от израза:

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

Както x, така и y ще съдържат стойността 3 .

Присвояването (x + = 2) прави две неща: първо, добавя 2 към стойността на променливата x , която става 3; второ, връща стойността на заданието, която също е 3 .

3. Видове оператори за сложно присвояване

Java поддържа 11 сложни оператори за присвояване. Можем да ги групираме в аритметични и побитови оператори.

Нека да разгледаме аритметичните оператори и операциите, които те извършват:

  • Увеличаване: + =
  • Декрементация: - =
  • Умножение: * =
  • Деление: / =
  • Модул: % =

След това имаме и битови оператори:

  • И, двоично: & =
  • Изключително ИЛИ, двоично: ^ =
  • Включително ИЛИ, двоично: | =
  • Ляв Shift, двоичен: << =
  • Десен Shift, двоичен: >> =
  • Преместете надясно нулево запълване: >>> =

Нека да разгледаме няколко примера за тези операции:

// 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

Както виждаме тук, синтаксисът за използване на тези оператори е последователен.

4. Оценка на операции за възлагане на съединения

Има два начина, по които Java оценява съставните операции.

Първо, когато левият операнд не е масив, тогава Java ще:

  1. Проверете дали операндът е декларирана променлива
  2. Запазете стойността на левия операнд
  3. Оценете десния операнд
  4. Извършете двоичната операция, както е указано от съставния оператор
  5. Преобразуване на резултата от двоичната операция в типа на лявата променлива (неявно кастинг)
  6. Присвойте преобразувания резултат на лявата променлива

След това, когато левият операнд е масив, стъпките, които трябва да следвате, са малко по-различни:

  1. Уверете се, израз на масива на лявата ръка и хвърли NullPointerException или ArrayIndexOutOfBoundsException ако това е неправилен
  2. Запазете елемента масив в индекса
  3. Оценете десния операнд
  4. Проверете дали избраният компонент на масив е примитивен тип или референтен тип и след това продължете със същите стъпки като първия списък, сякаш левият операнд е променлива.

Ако някоя стъпка от оценката се провали, Java не продължава да изпълнява следните стъпки.

Нека дадем няколко примера, свързани с оценката на тези операции с елемент от масив:

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

Както бихме очаквали, това ще хвърли NullPointerException .

Ако обаче присвоим начална стойност на масива:

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

Бихме се отървали от NullPointerException, но все пак щяхме да получим ArrayIndexOutOfBoundsException , тъй като използваният индекс не е правилен.

Ако поправим това, операцията ще бъде завършена успешно:

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

И накрая, променливата x ще бъде 6 в края на заданието.

5. Неявно кастинг

Една от причините съставните оператори да са полезни е, че те не само осигуряват по-кратък начин за операции, но и имплицитно излъчват променливи.

Формално, съставен израз на присвояване на формата:

E1 op = E2

е еквивалентно на:

E1 - (T) (E1 op E2)

където T е типът 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;

Това твърдение работи добре, леене резултат на умножение да вътр и присвояване на стойността на лявата страна променлива, аз .

6. Заключение

В тази статия разгледахме сложните оператори в Java, давайки някои примери и различни видове от тях. Обяснихме как Java оценява тези операции.

И накрая, прегледахме и неявно кастинг, една от причините тези стенографски оператори да са полезни.

Както винаги, всички кодови фрагменти, споменати в тази статия, могат да бъдат намерени в нашето хранилище на GitHub.