Изучаем Java. Арифметические операции
В логическом выражении могут использоваться следующие логические операторы : ==, !=,<=,>=,>,<, &&,||,! .
Рассмотрим на примере:
Int a = 4; int b = 5; boolean result; result = a == b // a равно b - false result = a != b // a не равно b - true result = a < b; // a меньше b - true result = a > b; // a больше b - false result = a <= 4 // a меньше или равно 4 - true result = b >= 6 // b больше или равно 6 - false result = a > b || a < b // (a больше b) логическое или (a меньше b) - true result = 3 < a && a < 6 // (3 меньше a) логическое и (a меньше 6) - true result = !result // логическое нет - false
Отличие == и equals
Оператор ==
работает иначе на объектных типах данных, нежели на примитивных. Когда мы используем объекты и хотим проверить их равенство, то оператор == укажет нам лишь на то, являются ли объекты одними и теми же или нет. Если же необходимо проверить логическое равенство объектов, то следует использовать метод equals
. Пример:
String str1 = new String("Привет"); String str2 = new String("Привет"); String sameStr = str1; boolean b1 = str1 == str2; // b1 - false, потому что str1 и str2 это 2 разных объекта boolean b2 = str1.equals(str2); // b2 - true, потому что str1 и str2 логически эквивалентны boolean b3 = str1 == sameStr ; // b3 -true, потому что str1 и sameStr в действительности один и тот же объект
Условный оператор if
Ели логическое выражение в скобках правдиво, то выполняется, блок кода в фигурных скобках {} после if. Если логическое выражение принимает значение false, то ничего не происходит.
If (a == b) { //Если a равно b - выводим сообщение System.out.println("a и b равны!"); }
Условный оператор if-else
Конструкция if-else отличается от предыдущей тем, что если логическое выражение в круглых скобках принимает значение false, то выполняется блок кода, находящийся в фигурных скобках после ключевого слова else
If (a == b) { //Если a равно b - выводим сообщение System.out.println("a и b равны!"); } else{ //Если a не равно b - выводим сообщение System.out.println("a и b не равны!"); }
Возможные сокращения if-else
1. Если блоки кода if, else содержат лишь одну строку , то можно обойтись без использования фигурных скобок. Предыдущий пример можем записать так:
If (a == b) System.out.println("a и b равны!"); else System.out.println("a и b не равны!");
2. Существует еще один способ сокращения оператора if-else при помощи оператора? : . Запишем предыдущий пример следующим образом:
System.out.println(a==b ? "a и b равны!" : "a и b не равны!");
Общая форма записи условия выглядит следующим образом:
Логическое_выражение? Выражение1: Выражение2
Если Логическое_выражение принимает значение true, то выполняется Выражение1, а иначе — Выражение2. Внимание : при использовании этой конструкции два последних выражения должны иметь один и тот же тип.
Условный оператор switch — case удобен в тех случаях, когда количество вариантов очень много и писать для каждого if-else очень долго. Конструкция имеет следующий вид:
Switch (выражение) { case значение1: //блок кода 1; break; case значение2: //блок кода 2; break; ... case значениеN: //блок кода N; break; default: блок N+1; }
switch работает с такими примитивными типами данных как: byte , short , char , и int . Также с типами Enum, классом String и несколькими специальными классами-оболочками примитивных типов: Character, Byte, Short, Integer.
Выражение в круглых скобках после switch сравнивается со значениями, указанными после слова case, и, в случае совпадения, управление передается соответствующему блоку кода. Если выражение не совпадает ни с одним вариантом case , то управление передается блоку default , который не является обязательным . После выполнения соответствующего блока, оператор break вызывает завершение выполнения оператора switch . Если break отсутствует, то управление передается следующему блоку за только что выполненным.
В следующем примере, для целочисленного значения, представляющего день недели, определяется его название в виде строки. Для значения 3, переменная dayString примет значение «Среда».
Int day = 3; String dayString; switch (day) { case 1: dayString = "Понедельник"; break; case 2: dayString = "Вторник"; break; case 3: dayString = "Среда"; break; case 4: dayString = "Четверг"; break; case 5: dayString = "Пятница"; break; case 6: dayString = "Суббота"; break; case 7: dayString = "Воскресенье"; break; default: dayString = "Ошибка"; break; } System.out.print(dayString);
Упражнения на тему Условные операторы в Java:
- Даны 4 числа типа int. Сравнить их и вывести наименьшее на консоль.
- Вывести на консоль количество максимальных чисел среди этих четырех.
- Даны 5 чисел (тип int). Вывести вначале наименьшее, а затем наибольшее из данных чисел.
- Даны имена 2х человек (тип String). Если имена равны, то вывести сообщение о том, что люди являются тезками.
- Дано число месяца (тип int). Необходимо определить время года (зима, весна, лето, осень) и вывести на консоль.
Укороченные (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
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. В этом уроке будут описаны различные типы циклов, как циклы могут быть использованы в разработке программ, и для каких целей они используются.
Операторы в Java
В Java поддерживаются следующие арифметические операторы (табл. 2.4).
Таблица 2.4. Арифметические операторы
Сложение
- Вычитание
* Умножение
/ Деление
% Вычисление остатка
++ Инкремент
-- Декремент
+= Присваивание со сложением
-= Присваивание с вычитанием
*= Присваивание с умножением
/= Присваивание с делением
%= Присваивание с вычислением остатка
Первые пять операторов всем знакомы по школьному курсу математики, причем два так называемых унарных оператора, и можно использовать для указания знака данною числа. Далее следуют операторы под названием инкремент (++) и декремент (- -).
Один из них (инкремент) прибавляет к значению переменной единицу, другой (декремент), наоборот, убавляет единицу.
Данные операторы указываются без пробела рядом со значением переменной. Если они стоят слева от переменной, то это называется префиксной формой инкремента или декремента, и это означает, что вначале к переменной прибавляется (или от нее отнимается) единица, а потом она используется в выражении. Если же инкремент (или декремент) ставится после имени переменной, то это называется постфиксной формой, и это означает, что переменная вначале используется в выражении, а затем к ней прибавляется (или от нее отнимается) единица.
Остальные пять операторов используются следующим образом:
а += b
аналогично записи:
а = а + b
Пример использования всех этих операторов приведен в листинге 2.9.
Листинг 2.9.
Пример использования арифметических операторов
class Example {
{
int a,b,c,d,e;
a=10
b= 11;
c= 12;
a+ = b; // a=21
a *= c; // a = 252
a = a - c; // a = 240
a -= c; // a = 228
d = 5;
e = 10;
System.out.println (++d); Выведется 6
System.out.println (d++); Выведется 6
System.out.println (e--) ; Выведется 10
System.out.println (--e) ; Выведется 8
}
}
Теперь рассмотрим битовые (поразрядные) операторы (табл. 2.5).
Таблица 2.5. Битовые (поразрядные) операторы
Оператор Описание
- Унарное отрицание
& Поразрядное И
| Поразрядное ИЛИ
^ Поразрядное исключающее ИЛИ
<< Сдвиг битов влево
>> Сдвиг битов вправо
>>> Сдвиг битов вправо с заполнением старшего бита нулем
&=, | =, ^=, <<=, >>=, >>>= Присвоение с аналогичной операцией
С помощью данных операторов мы работаем над числами в их двоичном представлении. Рассмотрим, например, запись числа 15 в двоичной форме. 00001111
Первый оператор, называемый унарным отрицанием, превращает 0 в 1, а 1 в 0. Оператор поразрядного "и" создает в итоге единицу, если у обоих аналогичных битов сравниваемых чисел тоже 1. Если у них другое сочетание чисел, то итог будет 0. Например:
С = А & В
Предположим, А = 15 (00001111), а В равно 10 (00001010). Число С в таком случае будет равно 10 (00001010). Поразрядное "ИЛИ" означает следующее: если хотя бы один из битов равен 1, то итог тоже 1. Поразрядное исключающее "ИЛИ" возвращает 1, если только один из битов сравниваемых чисел равно 1. Следующие три оператора сдвигают биты влево на указанное число разрядов, причем сдвиг битов влево заполняет пустые позиции нулями. Пример использования этих операторов приведен в табл. 2.6 и листинге 2.10.
Таблица 2.6. Операторы сдвигов битов
Листинг 2.10.
Пример использования операторов сдвигов битов
class Example
{
public static void main (String args)
{
int a=3, b=4, c=5;
int d = a * b;
System.out.println (d);
d = a | c;
System.out.println (d);
d &= a;
System.out.println (d);
}
}
В Java также поддерживаются и логические операторы, представленные в табл. 2.7.
Таблица 2.7. Логические операторы
Оператор Описание
= = Равно
!= Не равно
< Меньше
< = Меньше или равно
> Больше
> = Больше или равно
& Логическое и
| Логическое или
^ Логическое исключающее или
! Отрицание
&& Условное и
| | Условное или
&=, |=, ^= Присваивание с аналогичным оператором
Первые шесть операторов называются операторами сравнения. Они позволяют сравнивать числа и возвращают либо значение true, либо - false. Последующие четыре оператора работают с данным типа boolean, но по работе схожи с аналогичными битовыми операторами (только надо заменить бит 0 на false, а бит 1 - на true).
Следующие два оператора используются для двух условий сразу, т.е. указаны два условия и между ними ставится оператор "условное И". Если они оба будут равны true, то выводится значение true; если хотя бы одно из них будет false, то итог будет false.
Оператор "условное или" будет возвращать значение true, если хотя бы одно из условий будет true. Они обычно используются в конструкции if (об этом мы будем говорить в следующей главе). Пример использования всех этих операторов представлен в листинге 2.11.
Листинг 2.11.
Пример использования логических операторов
class Example
{
public static void main (String args)
{
int a = 10, b=15, c=20;
boolean b1 = a != b;
boolean b2 = с > a;
boolean b3 = b1 & b2;
boolean b4 = bЗ ^ b1;
if (b1 && b4 = = false) // Если b1 != b4, то:
bЗ = true;
else // Если это не так, то:
b2 = false;
}
}
Приведем схему использования логических операторов (табл. 2.8).
Таблица 2.8. Значения логических операторов для двух переменных