Бинарные операторы java. Логические операторы

Большинство операций над примитивными типами выполняется не с помощью методов, а с помощью специальных символов, называемых знаком операции .

Операция присваивания

Унарные операции

• унарный минус " - " – меняет знак числа или выражения на противоположный;
• унарный плюс " + " – не выполняет никаких действий над числом или выражением;
• побитовое дополнение " ~ " (только для целых) – инвертирует все биты поля числа (меняет 0 на 1 и 1 на 0);
• инкремент " ++ " (только для целых) – увеличивает значение переменной на 1;
• декремент " -- " (только для целых) – уменьшает значение переменной на 1.

Арифметические бинарные операции

• сложение " + ";
• вычитание " - ";
• умножение " * ";
• деление " / ";
• вычисление остатка от деления целых чисел " % " (возвращает остаток от деления первого числа на второе, причем результат будет иметь тот же знак, что и делимое), например, результат операции 5%3 будет равен 2 , а результат операции (-7)%(-4) будет равен -3 . В Java операция может использоваться и для вещественных переменных (типа float или double).

Побитовые операции

• Побитовые операции рассматривают исходные числовые значения как поля битов и выполняют над ними следующие действия:
• установка бита в i -ой позиции поля результата в 1 , если оба бита в i -ых позициях операндов равны 1 , или в 0 в противном случае – побитовое И (" & ");
• установка бита в i -ой позиции поля результата в 1 , если хотя бы один бит в i -ых позициях операндов равен 1 , или в 0 в противном случае – побитовое ИЛИ (" | ");
• установка бита в i -ой позиции поля результата в 1 , если биты в i -ых позициях операндов не равны друг другу, или в 0 в противном случае – побитовое исключающее ИЛИ (" ^ ");
• сдвиг влево битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг влево с учетом знака " << ";
• сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг вправо с учетом знака " >> ";
• сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом также сдвигается) – побитовый сдвиг вправо без учета знака " >>> ".

1. Побитовое И

   int x = 112 ; int y = 94 ; int z; z = x & y; // z=80: 00000000 00000000 00000000 01010000

2. Побитовое ИЛИ

   int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 int z; z = x | y; // z = 126: 00000000 00000000 00000000 01111110

3. Побитовое исключающее ИЛИ

   int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 int z; z = x ^ y; // z = 46: 00000000 00000000 00000000 00101110

4. Сдвиг влево с учетом знака

   int x = 31 , z; // x: 00000000 00000000 00000000 00011111 z = x << 2 ; // z = 124: 00000000 00000000 00000000 01111100

5. Сдвиг вправо с учетом знака

   int x = - 17 , z; z = x >> 2 ; // z = -5: 11111111 11111111 11111111 11111011

6. Сдвиг вправо без учета знака

   int x = - 17 , z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2 ; // z = 1073741819 // z: 00111111 11111111 11111111 11111011

Комбинированные операции

1. Выражение x += b означает x = x + b .
2. Выражение x -= b означает x = x - b .
3. Выражение x *= b означает x = x * b .
4. Выражение x /= b означает x = x / b .
5. Выражение x %= b означает x = x % b .
6. Выражение x &= b означает x = x & b .
7. Выражение x |= b означает x = x | b .
8. Выражение x ^= b означает x = x ^ b .
9. Выражение x <<= b означает x = x << b .
10. Выражение x >>= b означает x = x >> b .
11. Выражение x >>>= b означает x = x >>> b .

Операции сравнения

• " == " (равно), " != " (не равно),
• " > " (больше), " >= " (больше или равно),
• " < " (меньше) " <= " (меньше или равно)

Булевские операции

• отрицание "!" – замена false на true , или наоборот;
• операция И "&" – результат равен true , только, если оба операнда равны true , иначе результат – false ;
• операция ИЛИ " | " – результат равен true , только, если хотя бы один из операндов равен true , иначе результат – false .
• операция исключающее ИЛИ " ^ " – результат равен true , только, если операнды не равны друг другу, иначе результат – false .

Условная операция

Старшинство операций

Преобразование и приведение типов при выполнении операций

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

Из к/ф «Забытая мелодия для флейты»

Все операторы Java можно разделить на четыре группы: арифметические, логиче- ские, побитовые и сравнения. Рассмотрим последовательно каждую группу опе- раторов. Начнем с арифметических. Эти операторы перечислены в табл. 1.2.

Таблица 1.2. Арифметические операторы Java

Эти операторы имеют некоторые особенности. В первую очередь обращаем вни- мание на оператор деления /. Если операндами являются целые числа, в ка- честве значения возвращается результат целочисленного деления. Рассмотрим последовательность команд:

int a=5,b=2; double x=a/b;

В данном примере переменная x получает значение 2.0, а не 2.5, как можно было бы ожидать. Дело в том, что сначала вычисляется выражение a/b. Поскольку

операнды целочисленные, выполняется целочисленное деление. И только по- сле этого полученное значение преобразуется к формату double и присваивается переменной x.

Для того чтобы при целочисленных операндах выполнялось обычное деление, перед выражением с оператором деления указывается в круглых скобках иден- тификатор типа double (или float). Например, так:

double x=(double)a/b;

Теперь значение переменной x равно 2.5.

В Java, как и в С++, есть группа упрощенных арифметических операторов с присваиванием. Если op - один из операторов сложения, умножения, деления и вычисления остатка, то упрощенная форма этого оператора с присваиванием имеет вид op=. Это тоже бинарный оператор, как и оператор op, а команда вида x op=y является эквивалентом команды x=x op y.

Еще два исключительно полезных унарных оператора - операторы инкремента (++) и декремента (--). Действие оператора декремента сводится к увеличению на единицу значения операнда, а оператор декремента на единицу уменьшает операнд. Другими словами, команда x++ эквивалентна команде x=x+1, а команда x-- эквивалентна команде x=x-1. У операторов инкремента и декремента есть не только представленная здесь постфиксная форма (оператор следует после опе- ранда: x++ или x--), но и префиксная (оператор располагается перед операндом:

X или --x). С точки зрения действия на операнд нет разницы в том, префикс- ная или постфиксная формы оператора использованы. Однако если выражение с оператором инкремента или декремента является частью более сложного вы- ражения, различие в префиксной и постфиксной формах операторов инкремента и декремента существует. Если использована префиксная форма оператора, сна- чала изменяется значение операнда, а уже после этого вычисляется выражение. Если использована постфиксная форма оператора, сначала вычисляется выраже- ние, а затем изменяется значение операнда. Рассмотрим небольшой пример:

В этом случае после выполнения команд переменная n будет иметь значение 11, а переменная m - значение 10. На момент выполнения команды m=n++ значение переменной n равно 10. Поскольку в команде m=n++ использована постфиксная форма оператора инкремента, то сначала выполняется присваивание значения переменной m, а после этого значение переменной n увеличивается на единицу.

Иной результат выполнения следующих команд:

Обе переменные (n и m) в этом случае имеют значение 11. Поскольку в команде m=++n использована префиксная форма инкремента, сначала на единицу увели- чивается значение переменной n, а после этого значение переменной n присваи- вается переменной m.

Следующую группу образуют логические операторы. Операндами логических операторов являются переменные и литералы типа boolean. Логические опера- торы Java перечислены в табл. 1.3.

Таблица 1.3. Логические операторы Java

Логические операторы обычно используются в качестве условий в условных операторах и операторах цикла.

В табл. 1.4 перечислены операторы сравнения, используемые в Java.

Таблица 1.4. Операторы сравнения Java

Операторы сравнения обычно используются совместно с логическими операто- рами.

Для понимания принципов работы поразрядных операторов необходимо иметь хотя бы элементарные познания о двоичном представлении чисел. Напомним читателю некоторые основные моменты.

‰ В двоичном представлении позиционная запись числа содержит нули и еди- ницы.

‰ Старший бит (самый первый слева) определяет знак числа. Для положитель- ных чисел старший бит равен нулю, для отрицательных - единице.

‰ Перевод из двоичной системы счисления положительного числа с позицион-

ной записью

bnbn -1...b 2b 1b 0

(bi могут принимать значения 0 или 1, старший

бит для положительных чисел bn = 0) в десятичную выполняется так:

n -1 n

+ ... + bn -12

‰ Для перевода отрицательного двоичного числа в десятичное представление производится побитовое инвертирование кода (об операции побитового ин- вертирования - см. далее), полученное двоичное число переводится в деся- тичную систему, к нему прибавляется единица (и добавляется знак минус).

‰ Для перевода отрицательного числа из десятичной в двоичную систему от модуля числа отнимают единицу, результат переводят в бинарный код и затем этот код инвертируют.

‰ Умножение числа на два эквивалентно сдвигу влево на один бит позиционной записи числа (с заполнением первого бита нулем).

Побитовые операторы Java описаны в табл. 1.5.

Таблица 1.5. Побитовые операторы Java

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

Помимо перечисленных операторов, в Java есть единственный тернарный опе- ратор (у оператора три операнда). Формально оператор обозначается как?:. Синтаксис вызова этого оператора следующий:

условие?значение_1:значение_2

Первым операндом указывается условие - выражение, возвращающее в качестве значения логическое значение. Если значение выражения-условия равно true, в качестве значения тернарным оператором возвращается значение_1. Если зна- чением выражения-условия является false, тернарным оператором в качестве значения возвращается значение_2.

Несколько замечаний по поводу оператора присваивания (оператор =). В Java оператор присваивания возвращает значение. Команда вида x=y выполняется следующим образом. Сначала вычисляется выражение y, после чего это выра- жение приводится к типу переменной x и затем записывается в эту переменную. Благодаря тому, что, в отличие от других операторов с равными приоритетами, присваивание выполняется справа налево, в Java допустимыми являются ко- манды вида x=y=z. В этом случае значение переменной z присваивается сначала переменной y, а затем значение переменной y присваивается переменной x.

Еще одно замечание касается упрощенных форм операторов с присваиванием, то есть операторов вида op=. Хотя утверждалось, что команда вида A op=B эк- вивалента команде A=A op B, это не совсем так. При выполнении команды вида A op=B сначала вычисляется выражение A op B, затем полученное значение при- водится к типу переменной A и только после этого присваивается переменной A. Поскольку приведение к типу переменной A выполняется, фактически, явно, а в команде A=A op B приведение типов неявное, может проявиться разница

в использовании полной и упрощенной форм команд присваивания. Рассмо- трим простой пример:

// Правильно: a+=20;

// Неправильно: a=a+b;

В данном случае команда a+=20 является корректной, а команда a=a+b - нет. В первом случае литерал 20 типа int «насильственно» приводится к типу byte в силу особенностей оператора +=. Во втором случае результат вычисления вы- ражения a+b автоматически расширяется до типа int, а автоматическое приведе- ние типа int к типу byte запрещено.

Напоследок приведем в табл. 1.6 данные о приоритете различных операторов в Java.

Таблица 1.6. Приоритеты операторов в Java

Операторы равных приоритетов (за исключением присваивания) выполняются слева направо. В случаях когда возникают сомнения в приоритете операторов и последовательности вычисления выражений, рекомендуется использовать круглые скобки.

Последнее обновление: 30.10.2018

Большинство операций в Java аналогичны тем, которые применяются в других си-подобных языках. Есть унарные операции (выполняются над одним операндом), бинарные - над двумя операндами, а также тернарные - выполняются над тремя операндами. Операндом является переменная или значение (например, число), участвующее в операции. Рассмотрим все виды операций.

В арифметических операциях участвуют числами. В Java есть бинарные арифметические операции (производятся над двумя операндами) и унарные (выполняются над одним операндом). К бинарным операциям относят следующие:

операция сложения двух чисел:

Int a = 10; int b = 7; int c = a + b; // 17 int d = 4 + b; // 11

операция вычитания двух чисел:

Int a = 10; int b = 7; int c = a - b; // 3 int d = 4 - a; // -6

операция умножения двух чисел

Int a = 10; int b = 7; int c = a * b; // 70 int d = b * 5; // 35

операция деления двух чисел:

Int a = 20; int b = 5; int c = a / b; // 4 double d = 22.5 / 4.5; // 5.0

При делении стоит учитывать, так как если в операции участвуют два целых числа, то результат деления будет округляться до целого числа, даже если результат присваивается переменной float или double:

Double k = 10 / 4; // 2 System.out.println(k);

Чтобы результат представлял числос плавающей точкой, один из операндов также должен представлять число с плавающей точкой:

Double k = 10.0 / 4; // 2.5 System.out.println(k);

получение остатка от деления двух чисел:

Int a = 33; int b = 5; int c = a % b; // 3 int d = 22 % 4; // 2 (22 - 4*5 = 2)

Также есть две унарные арифметические операции, которые производятся над одним числом: ++ (инкремент) и -- (декремент). Каждая из операций имеет две разновидности: префиксная и постфиксная:

++ (префиксный инкремент)

Предполагает увеличение переменной на единицу, например, z=++y (вначале значение переменной y увеличивается на 1, а затем ее значение присваивается переменной z)

Int a = 8; int b = ++a; System.out.println(a); // 9 System.out.println(b); // 9

++ (постфиксный инкремент)

Также представляет увеличение переменной на единицу, например, z=y++ (вначале значение переменной y присваивается переменной z, а потом значение переменной y увеличивается на 1)

Int a = 8; int b = a++; System.out.println(a); // 9 System.out.println(b); // 8

-- (префиксный декремент)

уменьшение переменной на единицу, например, z=--y (вначале значение переменной y уменьшается на 1, а потом ее значение присваивается переменной z)

Int a = 8; int b = --a; System.out.println(a); // 7 System.out.println(b); // 7

-- (постфиксный декремент)

z=y-- (сначала значение переменной y присваивается переменной z, а затем значение переменной y уменьшается на 1)

Int a = 8; int b = a--; System.out.println(a); // 7 System.out.println(b); // 8

Приоритет арифметических операций

Одни операции имеют больший приоритет чем другие и поэтому выполняются вначале. Операции в порядке уменьшения приоритета:

++ (инкремент), -- (декремент)

* (умножение), / (деление), % (остаток от деления)

+ (сложение), - (вычитание)

Приоритет операций следует учитывать при выполнении набора арифметических выражений:

Int a = 8; int b = 7; int c = a + 5 * ++b; System.out.println(c); // 48

Вначале будет выполняться операция инкремента ++b , которая имеет больший приоритет - она увеличит значение переменной b и возвратит его в качестве результата. Затем выполняется умножение 5 * ++b , и только в последнюю очередь выполняется сложение a + 5 * ++b

Скобки позволяют переопределить порядок вычислений:

Int a = 8; int b = 7; int c = (a + 5) * ++b; System.out.println(c); // 104

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

Ассоциативность операций

Кроме приоритета операции отличаются таким понятием как ассоциативность . Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:

Левоассоциативные операторы, которые выполняются слева направо

Правоассоциативные операторы, которые выполняются справа налево

Так, некоторые операции, например, операции умножения и деления, имеют один и тот же приоритет. Какой же тогда будет результат в выражении:

Int x = 10 / 5 * 2;

Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты.

Поскольку все арифметические операторы (кроме префиксного инкремента и декремента) являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 , то есть результатом будет 4.

Операции с числами с плавающей точкой

Следует отметить, что числа с плавающей точкой не подходят для финансовых и других вычислений, где ошибки при округлении могут быть критичными. Например:

Double d = 2.0 - 1.1; System.out.println(d);

В данном случае переменная d будет равна не 0.9, как можно было бы изначально предположить, а 0.8999999999999999. Подобные ошибки точности возникают из-за того, что на низком уровне для представления чисел с плавающей точкой применяется двоичная система, однако для числа 0.1 не существует двоичного представления, также как и для других дробных значений. Поэтому если в таких случаях обычно применяется класс BigDecimal, который позволяет обойти подобные сиуации.

Большинство операций над примитивными типами выполняется не с помощью методов, а с помощью специальных символов, называемых знаком операции .

Операция присваивания

Унарные операции

• унарный минус " - " – меняет знак числа или выражения на противоположный;
• унарный плюс " + " – не выполняет никаких действий над числом или выражением;
• побитовое дополнение " ~ " (только для целых) – инвертирует все биты поля числа (меняет 0 на 1 и 1 на 0);
• инкремент " ++ " (только для целых) – увеличивает значение переменной на 1;
• декремент " -- " (только для целых) – уменьшает значение переменной на 1.

Арифметические бинарные операции

• сложение " + ";
• вычитание " - ";
• умножение " * ";
• деление " / ";
• вычисление остатка от деления целых чисел " % " (возвращает остаток от деления первого числа на второе, причем результат будет иметь тот же знак, что и делимое), например, результат операции 5%3 будет равен 2 , а результат операции (-7)%(-4) будет равен -3 . В Java операция может использоваться и для вещественных переменных (типа float или double).

Побитовые операции

• Побитовые операции рассматривают исходные числовые значения как поля битов и выполняют над ними следующие действия:
• установка бита в i -ой позиции поля результата в 1 , если оба бита в i -ых позициях операндов равны 1 , или в 0 в противном случае – побитовое И (" & ");
• установка бита в i -ой позиции поля результата в 1 , если хотя бы один бит в i -ых позициях операндов равен 1 , или в 0 в противном случае – побитовое ИЛИ (" | ");
• установка бита в i -ой позиции поля результата в 1 , если биты в i -ых позициях операндов не равны друг другу, или в 0 в противном случае – побитовое исключающее ИЛИ (" ^ ");
• сдвиг влево битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг влево с учетом знака " << ";
• сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг вправо с учетом знака " >> ";
• сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом также сдвигается) – побитовый сдвиг вправо без учета знака " >>> ".

1. Побитовое И

   int x = 112 ; int y = 94 ; int z; z = x & y; // z=80: 00000000 00000000 00000000 01010000

2. Побитовое ИЛИ

   int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 int z; z = x | y; // z = 126: 00000000 00000000 00000000 01111110

3. Побитовое исключающее ИЛИ

   int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 int z; z = x ^ y; // z = 46: 00000000 00000000 00000000 00101110

4. Сдвиг влево с учетом знака

   int x = 31 , z; // x: 00000000 00000000 00000000 00011111 z = x << 2 ; // z = 124: 00000000 00000000 00000000 01111100

5. Сдвиг вправо с учетом знака

   int x = - 17 , z; z = x >> 2 ; // z = -5: 11111111 11111111 11111111 11111011

6. Сдвиг вправо без учета знака

   int x = - 17 , z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2 ; // z = 1073741819 // z: 00111111 11111111 11111111 11111011

Комбинированные операции

1. Выражение x += b означает x = x + b .
2. Выражение x -= b означает x = x - b .
3. Выражение x *= b означает x = x * b .
4. Выражение x /= b означает x = x / b .
5. Выражение x %= b означает x = x % b .
6. Выражение x &= b означает x = x & b .
7. Выражение x |= b означает x = x | b .
8. Выражение x ^= b означает x = x ^ b .
9. Выражение x <<= b означает x = x << b .
10. Выражение x >>= b означает x = x >> b .
11. Выражение x >>>= b означает x = x >>> b .

Операции сравнения

• " == " (равно), " != " (не равно),
• " > " (больше), " >= " (больше или равно),
• " < " (меньше) " <= " (меньше или равно)

Булевские операции

• отрицание "!" – замена false на true , или наоборот;
• операция И "&" – результат равен true , только, если оба операнда равны true , иначе результат – false ;
• операция ИЛИ " | " – результат равен true , только, если хотя бы один из операндов равен true , иначе результат – false .
• операция исключающее ИЛИ " ^ " – результат равен true , только, если операнды не равны друг другу, иначе результат – false .

Условная операция

Старшинство операций

Преобразование и приведение типов при выполнении операций

Укороченные (short-circuit) логические операторы && и || предназначаются для логических AND (И) и OR (ИЛИ) операций над выражениями типа boolean . Заметьте, что для XOR (исключающее ИЛИ) операции не существует укороченного логического оператора.

Укороченные логические операторы похожи на операторы & и |, но в отличие от них применяются только к выражениям типа boolean и никогда не применяются к интегральным типам. Тем не менее, && и || обладают замечательным свойством: они укорачивают вычисление выражения, если результат может быть дедуцирован из части выражения (чуть позже я поясню это на примерах). Благодаря этому свойству, операторы && и || широко используются для обработки null-выражений. Они также помогают увеличить эффективность всей программы.

Свойство укорачивания вытекает прямым образом из различий между &&/|| и &/|: последняя пара операторов должна получать на вход значения левого и правого операторов, в то время как для первой пары операторов иногда достаточно знать значение только левого операнда, чтобы вернуть значение всего выражения. Такое поведение укороченных логических операторов базируется на двух математических правилах логической таблицы истинности :

• выражение с AND оператором ложно (false ), если значение хотя бы одного из его операндов ложно;
• выражение с OR оператором истинно (true ), если значение хотя бы одного из его операндов истинно.

• false AND X = false
• true OR X = true

Рассмотрим пример кода, который выводит сообщение String , если строка не нулевая и более 20 символов длиной:

1. if ((s != null) && (s.length() > 20)) {
2. System.out.println(s);
3. }

Эта же задача может быть закодиравана по-другому:

1. if (s != null) {
2. if (s.length() > 20) {
3. System.out.println(s);
4. }
5. }

Если бы строка s была null , то при вызове метода s.length() мы бы получили NullPointerException . Ни в одном из двух примеров кода, однако, такая ситауция не возникнет. В частности, во втором примере, s.length() не вызывается при s = null , благодаря использованию укороченного оператора &&. Если бы тест (s!=null) возвращал ложь (false ), то есть s - несуществующая строка, то и всё выражение гарантированно ложно. Значит, отпадает необхеодимость вычислять значение второго операнда, то есть выражения (s.length()>20) .

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

Рассмотрим пример:
// первый пример 1. int val = (int)(2 * Math.random()); 2. boolean test = (val == 0) || (++val == 2); 3. System.out.println(“test = “ + test + “\nval = “ + val); // второй пример 1. int val = (int)(2 * Math.random()); 2. boolean test = (val == 0)|(++val == 2); 3. System.out.println(“test = “ + test + “\nval = “ + val);
Первый пример иногда будет выводить на печать вот это:
test = true
val = 0

А иногда вот это:
test = true
val = 2

Второй пример иногда будет выводить на печать вот это:
test = true
val = 1

А иногда вот это:
test = true
val = 2

А дело вот в чём. Если val равно 0, то второй операнд (++val) никогда не будет вычислен, то есть val останется равным нулю. Если же изначально val равен единице, то в результате эта переменная будет инкрементирована и мы увидим val = 2 . Во втором примере, при использовании не укороченных операторов, инкремент выполняется всегда и результат будет всегда или 1 или 2 в зависимости от случайного значения выбранного на первом шаге. В обоих примерах переменная test принимает значение true , потому что либо val = 0 , либо val = 1 и инкрементируется до значения 2.

Резюмируем информацию об укороченных операторах && и ||:

• Они применяются к операндам типа boolean ;
• Они вычисляют значение правого операнда только если результат не может быть вычислен на основании значения левого операнда:
• false AND X = false
• true OR X = true