Логические операторы
Логические операторы языка Java выполняются только с операндами типа boolean .
Следующая таблица перечисляет логические операторы языка Java:
| Операция | Описание |
| & | Логическая операция И (AND) или конъюнкция |
| | | Логическая операция ИЛИ (OR) или дизъюнкция |
| ^ | Логическая операция исключающее ИЛИ (XOR) |
| ! | Логическая унарная операция НЕ (NOT) |
| || | Укороченная логическая операция ИЛИ (short-circuit) |
| && | Укороченная логическая операция И (short-circuit) |
| == | Равенство |
| != | Неравенство |
| &= | Логическая операция И с присваиванием |
| |= | Логическая операция ИЛИ с присваиванием |
| ^= | Логическая операция исключающее ИЛИ с присваиванием |
1. Логические операторы OR, AND, XOR, NOT.
Начнем с операций OR(|), AND(&), XOR(^), NOT(!). Операторы OR, AND, XOR являются бинарными — они требуют два оператора. NOT — это унарный оператор, только один оператор участвует в операции. Результаты выполнения этих логических операций представлены в следующей таблице:
| 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 |
OR (|) — результат будет true , если хотя бы одно значение равно true . Пример: для того, чтобы забрать ребенка из садика, должна прийти либо мать, либо отец, либо оба — в любом случае результат будет положительный. Если же никто не придет, ребенка не заберут — результат будет отрицательный.
AND (&) — результат будет true , только если и A, и B равны true . Пример: для того чтобы свадьба состоялась, и невеста (A) и жених (B) должны явиться на бракосочетание, иначе оно не состоится.
XOR (^) — результат будет true , только если или A равно true , или В равно true . Пример: у двух друзей на двоих один велосипед, поездка на велосипеде состоится только если один из них поедет на нем. Вдвоем они ехать не могут.
NOT (!) — инвертирование значения. Если значение было true, то станет false , и наоборот.
Рассмотрим пример использования логических операторов:
public class BooleanLogic1 < public static void main(String[] args) < boolean a = true; boolean b = false; boolean c = a | b; boolean d = a & b; boolean e = a ^ b; boolean f = (!a & b) | (a & !b); boolean g = !a; System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("a | b = " + c); System.out.println("a & b = " + d); System.out.println("a ^ b = " + e); System.out.println("(!a & b) | (a & !b) = " + f); System.out.println("!a header3">2. Укороченные логические операторы (short-circuit). Чаще всего в языке Java используются так называемые укороченные логические операторы (short-circuit):
|| - Укороченный логический оператор ИЛИ && - Укороченный логический оператор И Правый операнд сокращенных операций вычисляется только в том случае, если от него зависит результат операции, то есть если левый операнд конъюнкции имеет значение true, или левый операнд дизъюнкции имеет значение false.
В формальной спецификации языка Java укороченные логические операции называются условными.
В следующем примере правый операнд логического выражения вычисляться не будет, так как условие d!=0 не выполняется и нет смысла дальше вычислять это выражение:
public class BooleanLogic2 < public static void main(String[] args) < int d = 0; int num = 10; if (d != 0 && num / d >10) < System.out.println("num language-java">public class BooleanLogic3 < public static void main(String[] args) < int a = 1; int b = 2; int x = 3; System.out.print(a < x && x < b); // System.out.print(a < x < b);//Ошибка компиляции >>
3. Операции ==, !=.
Здесь все просто - чтобы сравнить два значения типа boolean , можно использовать знаки == (проверка на равенство) и != (проверка на неравенство):
public class BooleanLogic4 < public static void main(String[] args) < boolean b1 = true; boolean b2 = false; System.out.println(b1 == b2); System.out.println(b1 != b2); >>
4. Операции с присваиванием.
Также существуют операции с присваиванием для AND, OR, XOR. Посмотрим пример:
public class BooleanLogic5 < public static void main(String[] args) < boolean b1 = true; boolean b2 = true; b1 &= b2;//равносильно b1 = b1 & b2; System.out.println(b1); b1 |= b2; //равносильно b1 = b1 | b2; System.out.println(b1); b1 ^= b2; //равносильно b1 = b1 ^ b2; System.out.println(b1); >>
Презентацию с видео можно скачать на Patreon .
Логические операторы — AND, OR, NOT, XOR
Логические логические операторы выполняют логические операции с логическими операндами. Операторы включают унарное логическое отрицание ( ! ), двоичное логическое И (), OR ( & | ) и монопольное ИЛИ ( ^ ), а также двоичный условный логический и () и OR ( && || ).
- Унарный ! (логическое отрицание) оператор.
- Бинарные & (логическое И), | (логическое ИЛИ), а также ^ (логическое исключающее ИЛИ) операторы. Эти операторы всегда обрабатывают оба операнда.
- Бинарные && (условное логическое И) и || (условное логическое ИЛИ) операторы. Эти операторы вычисляют правый операнд, только если это необходимо.
Для операндов целочисленных типов операторы & , | и ^ выполняют побитовые логические операции. Дополнительные сведения см. в разделе Побитовые операторы и операторы сдвига.
Оператор логического отрицания !
Унарный префиксный оператор ! выполняет логическое отрицание операнда, возвращая true , если операнд имеет значение false , и false , если операнд имеет значение true .
bool passed = false; Console.WriteLine(!passed); // output: True Console.WriteLine(!true); // output: False
Унарный оператор постфикса ! является оператором , допускающим значение NULL.
Логический оператор AND &
Оператор & вычисляет логическое И для всех своих операндов. Результат операции x & y принимает значение true , если оба оператора x и y имеют значение true . В противном случае результат будет false .
Оператор & всегда вычисляет оба операнда. При оценке false левого операнда результат false операции независимо от значения правого операнда. Однако, даже тогда, правый операнд оценивается.
В следующем примере правый операнд оператора & является вызовом метода, который выполняется независимо от значения левого операнда:
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = false & SecondOperand(); Console.WriteLine(a); // Output: // Second operand is evaluated. // False bool b = true & SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True
Условный оператор логического И && также вычисляет логическое И для своих операндов, но не вычисляет правый операнд, если левый операнд имеет значение false .
Для операндов целочисленных типов оператор & вычисляет побитовое логическое И своих операндов. Унарный оператор & является оператором AddressOf.
Оператор логического исключения ИЛИ ^
Оператор ^ вычисляет логическое исключение ИЛИ для всех своих операндов, возвращая true для x ^ y , если x имеет значение true и y имеет значение false или x имеет значение false и y имеет значение true . В противном случае результат будет false . То есть для операндов bool оператор ^ возвращает тот же результат, что и оператор неравенства != .
Console.WriteLine(true ^ true); // output: False Console.WriteLine(true ^ false); // output: True Console.WriteLine(false ^ true); // output: True Console.WriteLine(false ^ false); // output: False
Для операндов целочисленных типов оператор ^ вычисляет побитовое исключающее ИЛИ своих операндов.
Оператор логического ИЛИ |
Оператор | вычисляет логическое ИЛИ для всех своих операндов. Результат операции x | y принимает значение true , если хотя бы один из операторов x или y имеет значение true . В противном случае результат будет false .
Оператор | всегда вычисляет оба операнда. При оценке true левого операнда результат true операции независимо от значения правого операнда. Однако, даже тогда, правый операнд оценивается.
В следующем примере правый операнд оператора | является вызовом метода, который выполняется независимо от значения левого операнда:
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = true | SecondOperand(); Console.WriteLine(a); // Output: // Second operand is evaluated. // True bool b = false | SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True
Условный оператор логического ИЛИ || также вычисляет логическое ИЛИ для своих операндов, но не вычисляет правый операнд, если левый операнд имеет значение true .
Для операндов целочисленных типов оператор | вычисляет побитовое логическое ИЛИ своих операндов.
Условный логический оператор AND &>
Условный оператор логического И && (оператор короткого замыкания) вычисляет логическое И для своих операндов. Результат операции x && y принимает значение true , если оба оператора x и y имеют значение true . В противном случае результат будет false . Если x вычисляется false значение , y не вычисляется.
В следующем примере правый операнд оператора && является вызовом метода, который не выполняется, если левый операнд имеет значение false :
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = false && SecondOperand(); Console.WriteLine(a); // Output: // False bool b = true && SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True
Оператор логического И & также вычисляет логическое И для своих операндов, но он всегда вычисляет оба операнда.
Условный оператор логического ИЛИ ||
Условный оператор логического ИЛИ || (оператор короткого замыкания) вычисляет логическое ИЛИ для своих операндов. Результат операции x || y принимает значение true , если хотя бы один из операторов x или y имеет значение true . В противном случае результат будет false . Если x вычисляется true значение , y не вычисляется.
В следующем примере правый операнд оператора || является вызовом метода, который не выполняется, если левый операнд имеет значение true :
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = true || SecondOperand(); Console.WriteLine(a); // Output: // True bool b = false || SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True
Оператор логического ИЛИ | также вычисляет логическое ИЛИ для своих операндов, но всегда вычисляет оба операнда.
Операторы, допускающие логическое значение NULL
Для операндов bool? операторы & (логическое И) и | (логическое ИЛИ) поддерживают следующую логику с тремя значениями:
- Оператор & возвращает true только в том случае, если оба операнда имеют значение true . Если x или y имеет значение false , оператор x & y возвращает false (даже если другой операнд имеет значение null ). В противном случае выражение x & y будет иметь значение null .
- Оператор | возвращает false только в том случае, если оба операнда имеют значение false . Если x или y имеет значение true , оператор x | y возвращает true (даже если другой операнд имеет значение null ). В противном случае выражение x | y будет иметь значение null .
Эта семантика описывается в следующей таблице:
x
г
x&y
x|y
true
true
true
true
true
false
false
true
true
null
null
true
false
true
false
true
false
false
false
false
false
null
false
null
null
true
null
true
null
false
false
null
null
null
null
null
Поведение этих операторов отличается от типичного поведения операторов, допускающих значение NULL. Как правило, оператор, определенный для операндов типа значения, также можно использовать с операндами соответствующего типа значения, допускающего значение NULL. Такой оператор возвращает null , если какой-либо из операндов имеет значение null . При этом операторы & и | могут возвращать отличное от NULL значение, даже если один из операндов имеет значение null . См. подробнее о поведении операторов, допускающих значение NULL, в разделе Операторы с нулификацией в статье Типы, допускающие значение NULL.
Вы также можете также использовать операторы ! и ^ с операндами bool? , как показано в следующем примере:
bool? test = null; Display(!test); // output: null Display(test ^ false); // output: null Display(test ^ null); // output: null Display(true ^ null); // output: null void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString());
Условные логические операторы && и || не поддерживают операнды типа bool? .
Составное присваивание
Для бинарного оператора op выражение составного присваивания в форме
x op= y
x = x op y
за исключением того, что x вычисляется только один раз.
Операторы & , | и ^ поддерживают составное присваивание, как показано в следующем примере:
bool test = true; test &= false; Console.WriteLine(test); // output: False test |= true; Console.WriteLine(test); // output: True test ^= false; Console.WriteLine(test); // output: True
Условные логические операторы && и || не поддерживают составное присваивание.
Приоритет операторов
В следующем списке перечислены логические операторы в порядке убывания приоритета:
- Оператор логического отрицания. !
- Оператор логического И &
- Оператор логического исключающего ИЛИ ^
- Оператор логического ИЛИ |
- Условный оператор логического И &&
- Условный оператор логического ИЛИ ||
Порядок вычисления, определяемый приоритетом операторов, можно изменить с помощью скобок ( () ).
Console.WriteLine(true | true & false); // output: True Console.WriteLine((true | true) & false); // output: False bool Operand(string name, bool value) < Console.WriteLine($"Operand is evaluated."); return value; > var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false); Console.WriteLine(byDefaultPrecedence); // Output: // Operand A is evaluated. // True var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false); Console.WriteLine(changedOrder); // Output: // Operand A is evaluated. // Operand C is evaluated. // False
Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе Приоритет операторов статьи Операторы C#.
Возможность перегрузки оператора
Определяемый пользователем тип может перегружать операторы ! , & , | и ^ . При перегрузке бинарного оператора соответствующий оператор составного присваивания также неявно перегружается. Явная перегрузка составного оператора присваивания для пользовательского типа невозможна.
Определяемый пользователем тип не может перегружать условные логические операторы && и || . При этом, если определяемый пользователем тип каким-либо образом перегружает операторы true и false и операторы & и | , операция && или || может быть применена для операндов этого типа. Дополнительные сведения см. в разделе Пользовательские условные логические операторы в Спецификации языка C#.
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
- Оператор логического отрицания
- Логические операторы
- Условные логические операторы
- Составное присваивание
См. также
- справочник по C#
- Операторы и выражения C#
- Побитовые операторы и операторы сдвига
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Логические операторы
Здесь мы рассмотрим первые пять, операторы ?? и ??= будут в следующей статье.
Несмотря на своё название, данные операторы могут применяться к значениям любых типов. Полученные результаты также могут иметь различный тип.
Давайте рассмотрим их подробнее.
|| (ИЛИ)
Оператор «ИЛИ» выглядит как двойной символ вертикальной черты:
result = a || b;
Традиционно в программировании ИЛИ предназначено только для манипулирования булевыми значениями: в случае, если какой-либо из аргументов true , он вернёт true , в противоположной ситуации возвращается false .
В JavaScript, как мы увидим далее, этот оператор работает несколько иным образом. Но давайте сперва посмотрим, что происходит с булевыми значениями.
Существует всего четыре возможные логические комбинации:
alert( true || true ); // true alert( false || true ); // true alert( true || false ); // true alert( false || false ); // false
Как мы можем наблюдать, результат операций всегда равен true , за исключением случая, когда оба аргумента false .
Если значение не логического типа, то оно к нему приводится в целях вычислений.
Например, число 1 будет воспринято как true , а 0 – как false :
if (1 || 0) < // работает как if( true || false ) alert( 'истинно!' ); >
Обычно оператор || используется в if для проверки истинности любого из заданных условий.
let hour = 9; if (hour < 10 || hour >18)
Можно передать и больше условий:
let hour = 12; let isWeekend = true; if (hour < 10 || hour >18 || isWeekend) < alert( 'Офис закрыт.' ); // это выходной >
ИЛИ "||" находит первое истинное значение
Описанная выше логика соответствует традиционной. Теперь давайте поработаем с «дополнительными» возможностями JavaScript.
Расширенный алгоритм работает следующим образом.
При выполнении ИЛИ || с несколькими значениями:
result = value1 || value2 || value3;
Оператор || выполняет следующие действия:
- Вычисляет операнды слева направо.
- Каждый операнд конвертирует в логическое значение. Если результат true , останавливается и возвращает исходное значение этого операнда.
- Если все операнды являются ложными ( false ), возвращает последний из них.
Значение возвращается в исходном виде, без преобразования.
Другими словами, цепочка ИЛИ || возвращает первое истинное значение или последнее, если такое значение не найдено.
alert( 1 || 0 ); // 1 (1 - истинное значение) alert( true || 'какая-то строка' ); // true alert( null || 1 ); // 1 (первое истинное значение) alert( null || 0 || 1 ); // 1 (первое истинное значение) alert( undefined || null || 0 ); // 0 (поскольку все ложно, возвращается последнее значение)
Это делает возможным более интересное применение оператора по сравнению с «чистым, традиционным, только булевым ИЛИ».
Получение первого истинного значения из списка переменных или выражений. Например, у нас есть переменные firstName , lastName и nickName , все они необязательные (т.е. они могут быть неопределенными или иметь ложные значения). Давайте воспользуемся оператором ИЛИ || , чтобы выбрать ту переменную, в которой есть данные, и показать её (или «Аноним», если ни в одной переменной данных нет):
let firstName = ""; let lastName = ""; let nickName = "Суперкодер"; alert( firstName || lastName || nickName || "Аноним"); // Суперкодер
Укороченные логические операторы
В C# предусмотрены также специальные, укороченные, варианты логических операторов И и ИЛИ, предназначенные для получения более эффективного кода. Поясним это на следующих примерах логических операций.
Если первый операнд логической операции И имеет ложное значение ( false ), то ее результат будет иметь ложное значение независимо от значения второго операнда.
Если же первый операнд логической операции ИЛИ имеет истинное значение ( true ), то ее результат будет иметь истинное значение независимо от значения второго операнда.
Благодаря тому, что значение второго операнда в этих операциях вычислять не нужно, экономится время и повышается эффективность кода.
Укороченная логическая операция И выполняется с помощью оператора && , а укороченная логическая операция ИЛИ — с помощью оператора || . Этим укороченным логическим операторам соответствуют обычные логические операторы & и | . Единственное отличие укороченного логического оператора от обычного заключается в том, что второй его операнд вычисляется только по мере необходимости.
В приведенном ниже примере программы демонстрируется применение укороченного логического оператора И. В этой программе с помощью операции деления по модулю определяется следующее: делится ли значение переменной d на значение переменной n нацело. Если остаток от деления n/d равен нулю, то n делится на d нацело.
Но поскольку данная операция подразумевает деление, то для проверки условия деления на нуль служит укороченный логический оператор И.
// Продемонстрировать применение укороченных логических операторов. using System; class SCops < static void Main() < int n, d; n = 10; d = 2; if (d != 0 && (n % d) == 0) Console.WriteLine(n + " делится нацело на " + d); d = 0; // задать нулевое значение переменной d // d равно нулю, поэтому второй операнд не вычисляется if (d != 0 && (n % d) == 0) Console.WriteLine(n + " делится нацело на " + d); // Если теперь попытаться сделать то же самое без укороченного // логического оператора, то возникнет ошибка из-за деления на нуль. if (d != 0 & (n % d) == 0) Console.WriteLine(n + " делится нацело на " + d); >>
Для исключения ошибки из-за деления на нуль в операторе if сначала проверяется условие: равно ли нулю значение переменной d . Если оно равно нулю, то на этом выполнение укороченного логического оператора И завершается, а последующая операция деления по модулю не выполняется. Так, при первой проверке значение переменной d оказывается равным 2, поэтому выполняется операция деления по модулю. А при второй проверке это значение оказывается равным нулю, следовательно, операция деления по модулю пропускается, чтобы исключить деление на нуль. И наконец, выполняется обычный логический оператор И, когда вычисляются оба операнда. Если при этом происходит деление на нуль, то возникает ошибка при выполнении.
Укороченные логические операторы иногда оказываются более эффективными, чем их обычные аналоги. Так зачем же нужны обычные логические операторы И и ИЛИ? Дело в том, что в некоторых случаях требуется вычислять оба операнда логической операции И либо ИЛИ из-за возникающих побочных эффектов. Рассмотрим следующий пример программы.
// Продемонстрировать значение побочных эффектов. using System; class SideEffects < static void Main() < int i; bool someCondition = false; i = 0; // Значение переменной i инкрементируется, // несмотря на то, что оператор if не выполняется. if (someCondition & (++i < 100)) Console.WriteLine("Не выводится"); Console.WriteLine("Оператор if выполняется: " + i); // выводится 1 // В данном случае значение переменной i не инкрементируется, // поскольку инкремент в укороченном логическом операторе опускается. if (someCondition && (++i < 100)) Console.WriteLine("Не выводится"); Console.WriteLine("Оператор if выполняется: " + i); // по-прежнему 1 !! >>
Прежде всего обратим внимание на то, что переменная someCondition типа bool инициализируется значением false . Далее проанализируем каждый оператор if . Как следует из комментариев к данной программе, в первом операторе if переменная i инкрементируется, несмотря на то, что значение переменной someCondition равно false . Когда применяется логический оператор & , как это имеет место в первом операторе if , выражение в правой части этого оператора вычисляется независимо от значения выражения в его левой части. А во втором операторе if применяется укороченный логический оператор. В этом случае значение переменной i не инкрементируется, поскольку левый операнд (переменная someCondition ) имеет значение false , следовательно, выражение в правой части данного оператора пропускается. Из этого следует вывод: если в коде предполагается вычисление правого операнда логической операции И либо ИЛИ, то необходимо пользоваться неукороченными формами логических операций, доступных в C#.
И последнее замечание: укороченный оператор И называется также условным логическим оператором И, а укороченный оператор ИЛИ — условным логическим оператором ИЛИ.