Операции java. Логические операторы. Операторы break и continue
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 имеется 44 встроенных оператора. Их можно разбить на 4 класса - арифметические, битовые, операторы сравнения и логические.
Арифметические операторы
Арифметические операторы используются для вычислений так же как в алгебре (см. таблицу со сводкой арифметических операторов ниже). Допустимые операнды должны иметь числовые типы. Например, использовать эти операторы для работы с логическими типами нельзя, а для работы с типом char можно, поскольку в Java тип char - это подмножество типа int.
Оператор |
Результат |
Оператор |
Результат |
Сложение |
сложение с присваиванием |
||
вычитание (также унарный минус) |
вычитание с присваиванием |
||
Умножение |
умножение с присваиванием |
||
деление с присваиванием |
|||
деление по модулю |
деление по модулю с присваиванием |
||
Инкремент |
декремент |
Четыре арифметических действия
Ниже, в качестве примера, приведена простая программа, демонстрирующая использование операторов. Обратите внимание на то, что операторы работают как с целыми литералами, так и с переменными.
class BasicMath{ public static void int a = 1 + 1;
intb = a *3;
main(String args) {
int c = b / 4;
int d = b - а;
int e = -d;
System.out.println("a =" +а);
System.out.println("b =" +b);
System.out.println("c =" +c);
System.out.println("d =" +d);
System.out.println("e =" +e);
} }
Исполнив эту программу, вы должны получить приведенный ниже результат:
C: \> java BasicMath
a = 2
b = 6
c = 1
d = 4
e = -4
Оператор деления по модулю
Оператор деления по модулю, или оператор mod, обозначается символом %. Этот оператор возвращает остаток от деления первого операнда на второй. В отличие от C++, функция mod в Java работает не только с целыми, но и с вещественными типами. Приведенная ниже программа иллюстрирует работу этого оператора.
class Modulus {
public static void main (String args ) {
int x = 42;
double у = 42.3;
System.out.println("x mod 10 = " + x % 10);
System.out.println("y mod 10 = " + у % 10);
} }
Выполнив эту программу, вы получите следующий результат:
С:\> Modulus
x mod 10 = 2
y mod 10 = 2.3
Арифметические операторы присваивания
Для каждого из арифметических операторов есть форма, в которой одновременно с заданной операцией выполняется присваивание. Ниже приведен пример, который иллюстрирует использование подобной разновидности операторов.
class OpEquals {
int a = 1;
int b = 2;
int с = 3;
a += 5;
b *= 4;
c += a * b;
с %= 6;
} }
А вот и результат, полученный при запуске этой программы:
С:> Java OpEquals
а = 6
b = 8
с = 3
Инкремент и декремент
В С существует 2 оператора, называемых операторами инкремента и декремента (++ и --) и являющихся сокращенным вариантом записи для сложения или вычитания из операнда единицы. Эти операторы уникальны в том плане, что могут использоваться как в префиксной, так и в постфиксной форме. Следующий пример иллюстрирует использование операторов инкремента и декреме нта.
class IncDec {
public static void main(String args) {
int a = 1;
int b = 2;
int c = ++b;
int d = a++;
c++;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
} }
Результат выполнения данной программы будет таким:
C:\ java IncDec
a = 2
b = 3
c = 4
d = 1
Целочисленные битовые операторы
Для целых числовых типов данных - long, int, short, char и byte, определен дополнительный набор операторов, с помощью которых можно проверять и модифицировать состояние отдельных битов соответствующих значений. В таблице приведена сводка таких операторов. Операторы битовой арифметики работают с каждым битом как с самостоятельной величиной.
Оператор |
Результат |
Оператор |
Результат |
побитовое унарное отрицание (NOT) |
|||
побитовое И (AND) |
побитовое И (AND) с присваиванием |
||
побитовое ИЛИ (OR) |
побитовое ИЛИ (OR) с присваиванием |
||
побитовое исключающее ИЛИ (XOR) |
побитовое исключающее ИЛИ (XOR) с присваиванием |
||
сдвиг вправо |
сдвиг вправо с присваиванием |
||
сдвиг вправо с заполнением нулями |
сдвиг вправо с заполнением нулями с присваиванием |
||
сдвиг влево |
сдвиг влево с присваиванием |
Пример программы, манипулирующей с битами
В таблице, приведенной ниже, показано, как каждый из операторов битовой арифметики воздействует на возможные комбинации битов своих операндов. Приведенный после таблицы пример иллюстрирует использование этих операторов в программе на языке Java.
class Bitlogic {
public static void main(String args ) {
String binary = { "OOOO", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001","1010", "1011", "1100", "1101",
"1110", "1111" };
int a = 3;//0+2+1или двоичное 0011
int b = 6;//4+2+0или двоичное 0110
int c = a | b;
int d = a & b;
int e = a ^ b;
int f = (~a & b) | (a & ~b);
int g = ~a & 0x0f;
System.out.println(" a = " + binary[a]);
System.out.println(" b = " + binary[b]);
System.out.println(" ab = " + binary[c]);
System.out.println(" a&b = " + binary[d]);
System.out.println(" a^b = " + binary[e]);
System.out.рrintln("~a&b|а^~Ь = " + binary[f]);
System.out.println(" ~a = " + binary[g]);
} }
Ниже приведен результат, полученный при выполнении этой программы:
С: \> Java BitLogic
a = 0011
b = 0110
a | b = 0111
a & b = 0010
a ^ b = 0101
~a & b | a & ~b = 0101
~а = 1100
Сдвиги влево и вправо
Оператор << выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями. В предыдущей главе уже говорилось об автоматическом повышении типа всего выражения до int в том случае если в выражении присутствуют операнды типа int или целых типов меньшего размера. Если же хотя бы один из операндов в выражении имеет тип long, то и тип всего выражения повышается до long.
Оператор >> означает в языке Java сдвиг вправо. Он перемещает все биты своего левого операнда вправо на число позиций, заданное правым операндом.Когда биты левого операнда выдвигаются за самую правую позицию слова, они теряются. При сдвиге вправо освобождающиеся старшие (левые) разряды сдвигаемого числа заполняются предыдущим содержимым знакового разряда. Такое поведение называют расширением знакового разряда.
В следующей программе байтовое значение преобразуется в строку, содержащую его шестнадцатиричное представление. Обратите внимание - сдвинутое значение приходится маскировать, то есть логически умножать на значение 0 х0 f, для того, чтобы очистить заполняемые в результате расширения знака биты и понизить значение до пределов, допустимых при индексировании массива шестнадцатиричных цифр.
classHexByte {
char hex = { "0", "1, "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f };
byte b = (byte) 0xf1;
System.out.println(“b = 0x” + hex[(b >> 4) & 0x0f] + hex);
} }
Ниже приведен результат работы этой программы:
С:\> java HexByte
b = 0xf1
Беззнаковый сдвиг вправо
Часто требуется, чтобы при сдвиге вправо расширение знакового разряда не происходило, а освобождающиеся левые разряды просто заполнялись бы нулями.
class ByteUShift{
static public void main(String args) {
char hex = { "0", "1’, "2", "3", "4","5", "6", "7", "8", "9", "а", "b", "с", "d","e", "f’ };
byte b = (byte) 0xf1;
byte c = (byte) (b >> 4);
byte d = (byte) (b >> 4);
byte e = (byte) ((b & 0xff) >> 4);
System.out.println(" b = 0x" + hex(b >> 4) & 0x0f] + hex);
System.out.println(“ b >> 4 =0x" + hex[(c >> 4) & 0x0f] + hex);
System.out.println(“b >>> 4 = 0x" + hex[(d >> 4) & 0x0f] + hex);
System.out.println(“(b & 0xff) >> 4 = 0x" + hex[(e >> 4) & 0x0f] + hex);
} }
Для этого примера переменную b можно было бы инициализировать произвольным отрицательным числом, мы использовали число с шестнадцатиричным представлением 0xf1. Переменной с присваивается результат знакового сдвига b вправо на 4 разряда. Как и ожидалось, расширение знакового разряда приводит к тому, что 0xf1 превращается в 0xff. Затем в переменную d заносится результат беззнакового сдвига b вправо на 4 разряда. Можно было бы ожидать, что в результате d содержит 0x0f, однако на деле мы снова получаем 0xff. Это - результат расширения знакового разряда, выполненного при автоматическом повышении типа переменной b до int перед операцией сдвига вправо. Наконец, в выражении для переменной е нам удается добиться желаемого результата - значения 0x0f. Для этого нам пришлось перед сдвигом вправо логически умножить значение переменной b на маску 0xff, очистив таким образом старшие разряды, заполненные при автоматическом повышении типа. Обратите внимание, что при этом уже нет необходимости использовать беззнаковый сдвиг вправо, поскольку мы знаем состояние знакового бита после операции AND.
С: \> java ByteUShift
b = 0xf1
b >> 4 = 0xff
b >>> 4 = 0xff
b & 0xff) >> 4 = 0x0f
Битовые операторы присваивания
Так же, как и в случае арифметических операторов, у всех бинарных битовых операторов есть родственная форма, позволяющая автоматически присваивать результат операции левому операнду. В следующем примере создаются несколько целых переменных, с которыми с помощью операторов, указанных выше, выполняются различные операции.
class OpBitEquals {
public static void main(String args) {
int a = 1;
int b = 2;
int с = 3;
a |= 4;
b >>= 1;
с <<= 1;
а ^= с;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
} }
Результаты исполнения программы таковы:
С:\> Java OpBitEquals
а = 3
b = 1
с = 6
Операторы отношения
Для того, чтобы можно было сравнивать два значения, в Java имеется набор операторов, описывающих отношение и равенство. Список таких операторов приведен в таблице.
Оператор |
Результат |
больше или равно |
|
меньше или равно |
Значения любых типов, включая целые и вещественные числа, символы, логические значения и ссылки, можно сравнивать, используя оператор проверки на равенство == и неравенство!=. Обратите внимание - в языке Java, так же, как в С и C++ проверка на равенство обозначается последовательностью (==). Один знак (=) - это оператор присваивания.
Булевы логические операторы
Булевы логические операторы, сводка которых приведена в таблице ниже, оперируют только с операндами типа boolean. Все бинарные логические операторы воспринимают в качестве операндов два значения типа boolean и возвращают результат того же типа.
Оператор |
Результат |
Оператор |
Результат |
логическое И (AND) |
И (AND) с присваиванием |
||
логическое ИЛИ (OR) |
ИЛИ (OR) с присваиванием |
||
логическое исключающее ИЛИ (XOR) |
исключающее ИЛИ (XOR) с присваиванием |
||
оператор OR быстрой оценки выражений (short circuit OR) |
|||
оператор AND быстрой оценки выражений (short circuit AND) |
|||
логическое унарное отрицание (NOT) |
тернарный оператор if-then-else |
Результаты воздействия логических операторов на различные комбинации значений операндов показаны в таблице.
Программа, приведенная ниже, практически полностью повторяет ужезнакомый вам пример BitLogic. Только но на этот раз мы работаем с булевыми логическими значениями.
class BoolLogic {
public static void main(String args) {
boolean a = true;
boolean b = false;
boolean с = 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 = " + g);
} }
С: \> Java BoolLogic
а = true
b = false
a|b = true
a&b = false
a^b = true
!a&b|a&!b = true
!a = false
Операторы быстрой оценки логических выражений (short circuit logical operators)
Существуют два интересных дополнения к набору логических операторов. Это - альтернативные версии операторов AND и OR, служащие для быстрой оценки логических выражений. Вы знаете, что если первый операнд оператора OR имеет значение true, то независимо от значения второго операнда результатом операции будет величина true. Аналогично в случае оператора AND, если первый операнд - false, то значение второго операнда на результат не влияет - он всегда будет равен false. Если вы в используете операторы && и || вместо обычных форм & и |, то Java не производит оценку правого операнда логического выражения, если ответ ясен из значения левого операнда. Общепринятой практикой является использование операторов && и || практически во всех случаях оценки булевых логических выражений. Версии этих операторов & и | применяются только в битовой арифметике.
Тернарный оператор if-then-else
Общая форма оператора if-then-use такова:
выражение1? выражение2: выражениеЗ
В качестве первого операнда - «выражение1» - может быть использовано любое выражение, результатом которого является значение типа boolean. Если результат равен true, то выполняется оператор, заданный вторым операндом, то есть, «выражение2». Если же первый операнд paвен false, то выполняется третий операнд - «выражениеЗ». Второй и третий операнды, то есть «выражение2» и «выражениеЗ», должны возвращать значения одного типа и не должны иметь тип void.
В приведенной ниже программе этот оператор используется для проверки делителя перед выполнением операции деления. В случае нулевого делителя возвращается значение 0.
class Ternary {
public static void main(String args) {
int a = 42;
int b = 2;
int c = 99;
int d = 0;
int e = (b == 0) ? 0: (a / b);
int f = (d == 0) ? 0: (c / d);
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
System.out.println("a / b = " + e);
System.out.println("c / d = " + f);
} }
При выполнении этой программы исключительной ситуации деления на нуль не возникает и выводятся следующие результаты:
С: \>java Ternary
а = 42
b = 2
с = 99
d = 0
a / b = 21
с / d= 0
Приоритеты операторов
В Java действует определенный порядок, или приоритет, операций. В элементарной алгебре нас учили тому, что у умножения и деления более высокий приоритет, чем у сложения и вычитания. В программировании также приходится следить и за приоритетами операций. В таблице указаны в порядке убывания приоритеты всех операций языка Java.
В первой строке таблицы приведены три необычных оператора, о которых мы пока не говорили. Круглые скобки () используются для явной установки приоритета. Как вы узнали из предыдущей главы, квадратные скобки используются для индексирования переменной-массива. Оператор. (точка) используется для выделения элементов из ссылки на объект - об этом мы поговорим в главе 7 . Все же остальные операторы уже обсуждались в этой главе.
Явные приоритеты
Поскольку высший приоритет имеют круглые скобки, вы всегда можете добавить в выражение несколько пар скобок, если у вас есть сомнения по поводу порядка вычислений или вам просто хочется сделать свои код более читабельным.
а >> b + 3
Какому из двух выражений, а >> (b + 3) или (а >> b) + 3, соответствует первая строка? Поскольку у оператора сложения более высокий приоритет, чем у оператора сдвига, правильный ответ - а>> (b + а). Так что если вам требуется выполнить операцию (а>>b)+ 3 без скобок не обойтись.
Итак, мы рассмотрели все виды операторов языка Java. Теперь вы можете сконструировать любое выражение с различными типами данных . В следующей главе познакомимся с конструкциями ветвления, организацией циклов и научимся управлять выполнением программы.