Рубрики
Без рубрики

Операторы Java-соединения

Узнайте, как работают сложные операторы на Java

Автор оригинала: baeldung.

1. Обзор

В этом учебнике мы посмотрим на операторов соединения Java, их типы и как Java оценивает их.

Мы также объясним, как неявное литье работает.

2. Операторы по назначению соединений

Оператор назначения — это бинарный оператор, который присваивает результат правой стороны переменной с левой стороны. Самый простой “=” оператор назначения:

int x = 5;

В этом заявлении объявляется новая переменная x , назначает x значение 5 и возвращает 5 .

Операторы сложных назначений — это более короткий способ применения арифметики или битной операции и присвоения значения операции переменной на левой стороне.

Например, следующие два заявления о умножении эквивалентны, что означает и 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 и у будет держать значение 3 .

Задание (х 2) делает две вещи: во-первых, он добавляет 2 к значению переменной x , который становится 3; во-вторых, возвращает значение уступки, которое также 3 .

3. Типы операторов назначения соединений

Java поддерживает 11 операторов сложных назначений. Мы можем сгруппить их в арифметических и битных операторов.

Давайте рассмотрим арифметических операторов и операций, которые они выполняют:

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

Затем, у нас также есть bitwise операторов:

  • И, двоичный: &=
  • Эксклюзивный OR, двоичный: ^=
  • Инклюзивный OR, двоичный: |=
  • Левая смена, двоичная: <<=
  • Правая смена, двоичный: >>=
  • Сдвиг правой нулевой заполнения: >>>=

Рассмотрим несколько примеров этих операций:

// 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. Проявите выражение массива на левой стороне и NullPointerЭксцепция или ArrayIndexOutOfBoundsException если это неправильно
  2. Сохранить элемент массива в индексе
  3. Оцените правую оперу
  4. Проверьте, является ли выбранный компонент массива примитивным типом или типом ссылки, а затем продолжить те же шаги, что и первый список, как если бы левый оперенд был переменной.

Если какой-либо шаг оценки не удается, Java не продолжает выполнять следующие шаги.

Давайте рассмотрим несколько примеров, связанных с оценкой этих операций, элемент массива:

int[] numbers = null;

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

Как и следовало ожидать, это бросит NullPointerЭксцепция .

Однако, если мы назначаем исходное значение массиву:

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

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

E1 – (T)(E1 op E2)

где T является типом E1 .

Рассмотрим следующий пример:

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

Давайте рассмотрим, почему последняя строка не будет компилироваться.

Java автоматически продвигает меньшие типы данных к более крупным, когда они вместе в операции, но будет бросать ошибку при попытке преобразовать из больших в меньшие типы .

Итак, во-первых, Я будут повышены до долго и тогда умножение даст результат 10L. Долгосрочный результат будет назначен Я , который является int , и это бросит ошибку.

Это может быть исправлено с явным актерским составом:

i = (int) i * number;

Операторы назначения соединения Java совершенны в этом случае, потому что они делают неявное литье:

i *= number;

Это утверждение работает просто отлично, бросая результат умножения, чтобы int и назначение значения левой боковой переменной, Я .

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

В этой статье мы рассмотрели сложных операторов в Java, приведение некоторых примеров и различных типов из них. Мы объяснили, как Java оценивает эти операции.

Наконец, мы также рассмотрели неявное литье, одна из причин, почему эти операторы сокращения являются полезными.

Как всегда, все фрагменты кода, упомянутые в этой статье, можно найти в нашем Репозиторий GitHub .