Логические операторы. Операции над примитивными типами в Java

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

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

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

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

Иными словами:

false AND X = false
true OR X = true

То есть, если левый операнд AND выражения ложен, то и всё выражение ложно, вне зависимости от значения правого операнда. То есть при ложном левом операнде нет нужны вычислять значение правого операнда. Аналогичным образом, если левый операнд OR выражения истиннен, то истинно и всё выражения, вне зависимости от значения правого операнда, которое, следовательно, нам не нужно вычислять.

Рассмотрим пример кода, который выводит сообщение 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

Логические операторы работают только с операндами типа boolean . Все логические операторы с двумя операндами объединяют два логических значения, образуя результирующее логическое значения. Не путайте с .

Таблица логических операторов в Java

Логические операторы & , | , ^ действуют применительно к значениям типа boolean точно так же, как и по отношению к битам целочисленных значений. Логический оператор ! инвертирует (меняет на противоположный) булево состояние: !true == false и !false == true .

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

A	B	A \| B	A & B	A ^ B	!A
false	false	false	false	false	true
true	false	true	false	true	false
false	true	true	false	true	true
true	true	true	true	false	false

Сокращённые логические операторы

Кроме стандартных операторов AND (&) и OR (|) существуют сокращённые операторы && и || .

Если взглянуть на таблицу, то видно, что результат выполнения оператора OR равен true true , независимо от значения операнда B. Аналогично, результат выполнения оператора AND равен false , когда значение операнда A равно false , независимо от значения операнда B. Получается, что нам не нужно вычислять значение второго операнда, если результат можно определить уже по первому операнду. Это становится удобным в тех случаях, когда значение правого операнда зависит от значения левого.

Рассмотрим следующий пример. Допустим, мы ввели правило - кормить или не кормить кота в зависимости от числа пойманных мышек в неделю. Причём число мышек зависит от веса кота. Чем больше кот, тем больше он должен поймать мышей.

Кот, прочитавший условие задачи, обиделся на меня. Он заявил, что я отстал от жизни, а на дворе 21 век - мышей можно ловить с помощью мышеловок. Пришлось объяснять ему, что это всего лишь задачка, а не пример из личной жизни.

Int mouse; // число мышек int weight; // вес кота в граммах mouse = 5; weight = 4500; if (mouse != 0 & weight / mouse < 1000) { mInfoTextView.setText("Можно кормить кота"); }

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

Теперь возьмём крайний случай. Кот обленился и не поймал ни одной мышки. Значение переменной mouse будет равно 0, а в выражении есть оператор деления. А делить на 0 нельзя и наша программа закроется с ошибкой. Казалось бы, мы предусмотрели вариант с 0, но Java вычисляет оба выражения mouse != 0 и weight / mouse < 1000 , несмотря на то, что уже в первом выражении возвращается false .

Перепишем условие следующим образом (добавим всего лишь один символ):

If (mouse != 0 && weight / mouse < 1000) { mInfoTextView.setText("Можно кормить кота"); }

Теперь программа работает без краха. Как только Java увидела, что первое выражение возвращает false , то второе выражение с делением просто игнорируется.

Сокращённые варианты операторов AND и OR принято использовать в тех ситуациях, когда требуются операторы булевой логики, а их односимвольные родственники используются для побитовых операций.

Тернарный оператор

В языке Java есть также специальный тернарный условный оператор, которым можно заменить определённые типы операторов if-then-else - это оператор ?:

Тернарный оператор использует три операнда. Выражение записывается в следующей форме:

ЛогическоеУсловие? выражение1: выражение2

Если логическоеУсловие равно true , то вычисляется выражение1 и его результат становится результатом выполнения всего оператора. Если же логическоеУсловие равно false , то вычисляется выражение2 , и его значение становится результатом работы оператора. Оба операнда выражение1 и выражение2 должны возвращать значение одинакового (или совместимого) типа.

Рассмотрим пример, в котором переменной absval присваивается абсолютное значение переменной val .

Int absval, val; val = 5; absval = val < 0 ? -val: val; // выводим число mInfoTextView.setText("" + absval); val = -5; absval = val < 0 ? -val: val; mInfoTextView.setText("" + absval);

Переменной absval будет присвоено значение переменной val , если значение больше или равно нулю (вторая часть выражения). Если значение переменной val отрицательное , то переменной absval присваивается значение переменной, взятое со знаком минус, в результате минус на минус даст плюс, то есть положительно значение. Перепишем код с использованием if-else :

If(val < 0) absval = -val; else absval = val;

Другой пример с тернарным оператором можете посмотреть .

Java предоставляет богатый набор операторов для управления переменными. Все операторы Java можно разделить на следующие группы:

арифметические операторы;
операторы сравнения;
побитовые операторы;
логические операторы;
операторы присваивания;
прочие операторы.

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

Арифметические операторы - используются в математических выражениях таким же образом, как они используются в алгебре. Предположим, целая переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены арифметические операторы в Java:

Пример

Следующий простой пример показывает программно арифметические операторы. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:

Public class Test { public static void main(String args) { int a = 10; int b = 20; int c = 25; int d = 25; System.out.println("a + b = " + (a + b)); System.out.println("a - b = " + (a - b)); System.out.println("a * b = " + (a * b)); System.out.println("b / a = " + (b / a)); System.out.println("b % a = " + (b % a)); System.out.println("c % a = " + (c % a)); System.out.println("a++ = " + (a++)); System.out.println("b-- = " + (a--)); // Проверьте разницу в d++ и ++d System.out.println("d++ = " + (d++)); System.out.println("++d = " + (++d)); } }

A + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5 a++ = 10 b-- = 11 d++ = 25 ++d = 27

Операторы сравнения

Есть следующие операторы сравнения, поддерживаемые на языке Java. Предположим, переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены реляционные операторы или операторы сравнения в Java:

Оператор	Описание	Пример
==	Проверяет, равны или нет значения двух операндов, если да, то условие становится истинным	(A == B) - не верны
!=	Проверяет, равны или нет значения двух операндов, если значения не равны, то условие становится истинным	(A != B) - значение истинна
>	Проверяет, является ли значение левого операнда больше, чем значение правого операнда, если да, то условие становится истинным	(A > B) - не верны
	Проверяет, является ли значение левого операнда меньше, чем значение правого операнда, если да, то условие становится истинным	(A
>=	Проверяет, является ли значение левого операнда больше или равно значению правого операнда, если да, то условие становится истинным	(A >= B) - значение не верны
	Проверяет, если значение левого операнда меньше или равно значению правого операнда, если да, то условие становится истинным	(A

Пример

Следующий простой пример показывает, программно операторы сравнения в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:

Public class Test { public static void main(String args) { int a = 10; int b = 20; System.out.println("a == b = " + (a == b)); System.out.println("a != b = " + (a != b)); System.out.println("a > b = " + (a > b)); System.out.println("a = a = " + (b >= a)); System.out.println("b

A == b = false a != b = true a > b = false a = a = true b

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

Java определяет несколько побитовых операторов, которые могут быть применены для целочисленных типов: int, long, short, char и byte. В Java побитовый оператор работает над битами и выполняет операцию бит за битом. Предположим, если a = 60; и b = 13; то в двоичном формате они будут следующие:

a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011

Предположим целочисленные переменная A равна 60, а переменная B равна 13. В следующей таблице перечислены побитовые операторы в Java:

Оператор	Описание	Пример
& (побитовое и)	Бинарный оператор AND копирует бит в результат, если он существует в обоих операндах.	(A & B) даст 12, который является 0000 1100
\| (побитовое или)	Бинарный оператор OR копирует бит, если он существует в любом из операндов.	(A \| B) даст 61 который равен 0011 1101
^ (побитовое логическое или)	Бинарный оператор XOR копирует бит, если он установлен в одном операнде, но не в обоих.	(A ^ B) даст 49, которая является 0011 0001
~ (побитовое дополнение)	Бинарный оператор дополнения и имеет эффект «отражения» бит.	(~ A) даст -61, которая является формой дополнением 1100 0011 в двоичной записи
	Бинарный оператор сдвига влево. Значение левых операндов перемещается влево на количество бит, заданных правым операндом.	A
>> (сдвиг вправо)	Бинарный оператор сдвига вправо. Значение правых операндов перемещается вправо на количество бит, заданных левых операндом.	A >> 2 даст 15, который является 1111
>>> (нулевой сдвиг вправо)	Нулевой оператор сдвига вправо. Значение левых операндов перемещается вправо на количество бит, заданных правым операндом, а сдвинутые значения заполняются нулями.	A >>> 2 даст 15, который является 0000 1111

Пример

Следующий простой пример показывает, программно побитовые операторы в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:

Public class Test { public static void main(String args) { int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */ int c = 0; c = a & b; /* 12 = 0000 1100 */ System.out.println("a & b = " + c); c = a | b; /* 61 = 0011 1101 */ System.out.println("a | b = " + c); c = a ^ b; /* 49 = 0011 0001 */ System.out.println("a ^ b = " + c); c = ~a; /*-61 = 1100 0011 */ System.out.println("~a = " + c); c = a > 2; /* 215 = 1111 */ System.out.println("a >> 2 = " + c); c = a >>> 2; /* 215 = 0000 1111 */ System.out.println("a >>> 2 = " + c); } }

Будет получен следующий результат:

A & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a > 15 a >>> 15

Логические операторы

Предположим, логическая переменная A имеет значение true, а переменная B хранит false. В следующей таблице перечислены логические операторы в Java:

Пример

Public class Test { public static void main(String args) { boolean a = true; boolean b = false; System.out.println("a && b = " + (a&&b)); System.out.println("a || b = " + (a||b)); System.out.println("!(a && b) = " + !(a && b)); } }

Это произведет следующий результат:

A && b = false a || b = true !(a && b) = true

Операторы присваивания

Существуют следующие операторы присваивания, поддерживаемые языком Java:

Оператор	Описание	Пример
=	Простой оператор присваивания, присваивает значения из правой стороны операндов к левому операнду	C = A + B, присвоит значение A + B в C
+=	Оператор присваивания «Добавления», он присваивает левому операнду значения правого	C += A, эквивалентно C = C + A
-=	Оператор присваивания «Вычитания», он вычитает из правого операнда левый операнд	C -= A, эквивалентно C = C - A
*=	Оператор присваивания «Умножение», он умножает правый операнд на левый операнд	C * = A эквивалентно C = C * A
/=	Оператор присваивания «Деление», он делит левый операнд на правый операнд	C /= A эквивалентно C = C / A
%=	Оператор присваивания «Модуль», он принимает модуль, с помощью двух операндов и присваивает его результат левому операнду	C %= A, эквивалентно C = C % A
	Оператор присваивания «Сдвиг влево»	C
>>=	Оператор присваивания «Сдвиг вправо»	C >>= 2, это как C = C >> 2
&=	Оператор присваивания побитового «И» («AND»)	C &= 2, это как C = C & 2
^=	Оператор присваивания побитового исключающего «ИЛИ» («XOR»)	C ^= 2, это как C = C ^ 2
\|=	Оператор присваивания побитового «ИЛИ» («OR»)	C \|= 2, это как C = C \| 2

Пример

Следующий простой пример показывает, программно логические операторы в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:

Public class Test { public static void main(String args) { int a = 10; int b = 20; int c = 0; c = a + b; System.out.println("c = a + b = " + c); c += a ; System.out.println("c += a = " + c); c -= a ; System.out.println("c -= a = " + c); c *= a ; System.out.println("c *= a = " + c); a = 10; c = 15; c /= a ; System.out.println("c /= a = " + c); a = 10; c = 15; c %= a ; System.out.println("c %= a = " + c); c >= 2 ; System.out.println("c >>= 2 = " + c); c >>= 2 ; System.out.println("c >>= a = " + c); c &= a ; System.out.println("c &= 2 = " + c); c ^= a ; System.out.println("c ^= a = " + c); c |= a ; System.out.println("c |= a = " + c); } }

Будет получен следующий результат:

C = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c >= 2 = 5 c >>= 2 = 1 c &= a = 0 c ^= a = 10 c |= a = 10

Прочие операторы

Есть несколько других операторов, поддерживаемых языком Java.

Тернарный оператор или условный оператор (?:)

Тернарный оператор - оператор, который состоит из трех операндов и используется для оценки выражений типа boolean. Тернарный оператор в Java также известен как условный оператор. Этот. Цель тернарного оператора или условного оператора заключается в том, чтобы решить, какое значение должно быть присвоено переменной. Оператор записывается в виде:

Переменная x = (выражение) ? значение if true: значение if false

Пример

Ниже приведен пример:

Public class Test { public static void main(String args){ int a , b; a = 10; b = (a == 1) ? 20: 30; System.out.println("Значение b: " + b); b = (a == 10) ? 20: 30; System.out.println("Значение b: " + b); } }

Будет получен следующий результат:

Значение b: 30 Значение b: 20

Оператор instanceof

Оператор instanceof - проверяет, является ли объект определенного типа (типа класса или типа интерфейса) и используется только для переменных ссылочного объекта. Оператор instanceof записывается в виде:

(Переменная ссылочного объекта) instanceof (класс/тип интерфейса)

Примеры

Если переменная ссылочного объекта в левой части оператора проходит проверку для класса/типа интерфейса на правой стороне, результатом будет значение true. Ниже приведен пример и описание оператора instanceof:

Public class Test { public static void main(String args){ String name = "Олег"; // Следующее вернётся верно, поскольку тип String boolean result = name instanceof String; System.out.println(result); } }

Будет получен следующий результат:

Этот оператор по-прежнему будет возвращать значение true, если сравниваемый объект является совместимым с типом на право назначения. Ниже приводится еще один пример:

Class Vehicle {} public class Car extends Vehicle { public static void main(String args){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println(result); } }

Будет получен следующий результат:

Приоритет операторов в Java

Приоритет операторов определяет группирование терминов в выражении. Это влияет как вычисляется выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например оператор умножения имеет более высокий приоритет, чем оператор сложения:

Например, x = 7 + 3 * 2. Здесь x присваивается значение 13, не 20, потому что оператор «*» имеет более высокий приоритет, чем «+», так что сначала перемножается «3 * 2», а затем добавляется «7».

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

Категория	Оператор	Ассоциативность
Постфикс	() . (точка)	Слева направо
Унарный	++ - - ! ~	Справа налево
Мультипликативный	* / %	Слева направо
Аддитивный	+ -	Слева направо
Сдвиг	>> >>>	Слева направо
Реляционный	> >=	Слева направо
Равенство	== !=	Слева направо
Побитовое «И» («AND»)	&	Слева направо
Побитовое исключающее «ИЛИ» («XOR»)	^	Слева направо
Побитовое «ИЛИ» («OR»)	\|	Слева направо
Логическое «И» («AND»)	&&	Слева направо
Логическое «ИЛИ» («OR»)	\|\|	Слева направо
Условный	?:	Справа налево
Присваивание	= += -= *= /= %= >>=	Справа налево
Запятая	,	Слева направо

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