Какие из следующих операторов называются укороченными

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

Логические операторы языка 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.
Оператор логического И &
Оператор & вычисляет логическое И для всех своих операндов. Результат операции 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 .
Для операндов целочисленных типов оператор | вычисляет побитовое логическое ИЛИ своих операндов.
Условный оператор логического И &&
Условный оператор логического И && (оператор короткого замыкания) вычисляет логическое И для своих операндов. Результат операции 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
y
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, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
 Java 
© 2008 Наталия Македа 
Все материалы блога защищены авторским правом. Любая перепечатка или использование материалов этого блога в коммерческих целях возможна лишь с письменного согласия автора. При некоммерческом использовании ссылка на блог обязательна.
среда, 20 августа 2008 г.
2.7 Укороченные (short-circuit) логические операторы (Выпуск 10) 
Укороченные (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) < 
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

Укороченные логические операторы
В 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#.
И последнее замечание: укороченный оператор И называется также условным логическим оператором И, а укороченный оператор ИЛИ — условным логическим оператором ИЛИ.


Похожие публикации:

Как активировать виндовс 11 про
Как выровнять текст внутри блока css
Как открыть закрытый файл в ворде
Как поменять язык в яндекс музыке на телефоне





		
		Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Имя * 
Email * 
Сайт 
Комментарий * 
 Сохранить моё имя, email и адрес сайта в этом браузере для последующих моих комментариев.