Шифрование с помощью циклического сдвига java. Побитовые операции. сдвиг вправо с заполнением нулями

Конспект лекций по Java. Занятие 4

(none) (none) ::
(none)
( В.Фесюнов )

Операции (operators) в языке Java

Большинство операций Java просты и интуитивно понятны. Это такие операции, как +, -, *, /, <,> и др. Операции имеют свой порядок выполнения и приоритеты. Так в выражении

сначала выполняется умножение, а потом сложение, поскольку приоритет у операции умножения выше, чем у операции сложения. В выражении

сначала вычисляется a + b, а потом от результата вычитается c, поскольку порядок выполнения этих операций слева направо.

Но операции Java имеют и свои особенности. Не вдаваясь в детальное описание простейших операций, остановимся на особенностях.

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

• Операция присваивания обозначается символом "=". Она вычисляет значение своего правого операнда и присваивает его левому операнду, а также выдает в качестве результата присвоенное значение. Это значение может быть использовано другими операциями. Последовательность из нескольких операций присваивания выполняется справа налево.

В простейшем случае все выглядит как обычно.

Здесь происходит именно то, что мы интуитивно подразумеваем, — вычисляется сумма a и b, результат заносится в x. Но вот два других примера.

В первом сначала 1 заносится в b, результатом операции является 1, потом этот результат заносится в a. Во втором примере вычисляется сумма a и b и результат теряется. Это бессмысленно, но синтаксически допустимо.

Операции сравнения

Это операции >, <, >=, <=, != и ==. Следует обратить внимание, что сравнение на равенство обозначается двумя знаками "=". Операндами этих операций могут быть арифметические данные, результат — типа boolean.

Операции инкремента, декремента

Это операции ++ и --. Так y++ (инкремент) является сокращенной записью y = y +1, аналогично и с операцией декремента (--).

Но с этими операциями есть одна тонкость. Они существуют в двух формах - префиксной (++y) и постфиксной (y++). Действие этих операций одно и то же — они увеличивают (операции декремента — уменьшают) свой операнд на 1, а вот результат у них разный. Префиксная форма в качестве результата выдает уже измененное на 1 значение операнда, а постфиксна -значение операнда до изменения.

A = 5; x = a++; y = ++a;

В этом фрагменте x получит значение 5, а y — 7.

Операция целочисленного деления

Нужно учитывать, что деление одного целого на другое выдает целое, причем не округляет, а отбрасывает дробную часть.

Остаток от деления (значение по модулю)

В Java имеется операция %, которая обозначает остаток от деления.

Расширенные операции присваивания

Кроме обычной операции "=" в Java существуют операции +=, -=, *=, /= и др. Это сокращенные записи. Так a += b полностью эквивалентна a = a + b. Аналогично и с другими такими операциями.

Логические операции

! — отрицание && — логическое "и" || — логическое "или"

Операнды этих операций должны быть типа boolean, результат — boolean. Операции && и || имеют одну особенность — их правый операнд может и не вычислиться, если результат уже известен по левому операнду. Так, если левый операнд операции && — ложь (false), то правый операнд вычисляться не будет, т.к. результат все равно — ложь.

Это свойство нужно учитывать, особенно тогда, когда правый операнд содержит вызов некоторой функции.

Побитовые логические операции

Это операции

& — побитовое "и" | — побитовое "или" ^ — побитовое "исключающее или" ~ — побитовое отрицание

Они выполняются для каждой пары битов своих операндов.

Операции сдвига

<< — сдвиг влево >> — сдвиг вправо >>> — беззнаковый сдвиг вправо

Эти операции сдвигают значение своего левого операнда на число бит, заданное правым операндом.

Условная операци

Это единственная тернарная операция, т.е. операция, имеющая три операнда. Соответственно, для нее используется не один знак операции, а два.

<условие> ? <выражение1> : < выражение2>

Если <условие> истинно, то результатом будет < выражение1>, иначе < выражение2>.

Например, "a < b ? a: b" вычисляет минимум из a и b.

Операция приведения типов

Это очень важная операция. По умолчанию все преобразования, которые могут привести к проблемам, в Java запрещены. Так, нельзя long-значение присвоить int-операнду. В тех случаях, когда это все же необходимо, нужно поставить явное преобразование типа.

Например, пусть метод f(...) выдает long.

int x = (int)f(10);

Здесь (int) — это операция преобразования типа. Операция преобразования типа обозначается при помощи имени типа, взятого в скобки.

Эта операция применима не только к базовым типам, но и к классам. Мы разберем это подробнее, когда будем рассматривать наследование.

Литералы (константы)

Арифметические

Примеры арифметических констант

10 - 010 — это 8 - 0123 — это 83 (1*64 + 2*8 + 3) - 0x10 — это 16 - 0x123 — это 291 (1*256 + 2*16 +3) - 1e5 — это 100000 - 1.23e-3 — это 0.00123

Для указания типа константы применяются суффиксы: l (или L) — long, f (или F) — float, d (или D) — double. Например,

1L — единица, но типа long.

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

Логические литералы — это true (истина) и false (ложь)

Строковые литералы

Записываются в двойных кавычках, например

"это строка"

Символьные литералы

Записываются в апострофах, например "F", "ш".

В строковых и символьных литералах есть правила для записи спец. символов. Во-первых, есть набор предопределенных спец. символов. Это

- "\n" — конец строки (перевод строки) - "\r" — возврат каретки - "\t" — табуляция

и ряд других.

Во-вторых, можно явно записать код символа (нужно только знать его). Запись кода обычно выполняется в восьмеричной системе: "\001" — символ с кодом 1 и т.п.

Операторы (statements)

Оператор — выражение

Синтаксис

<выражение>;

Такой оператор состоит из одного выражения, в конце стоит ";". Его действие состоит в вычислении выражения, значение, вычисленное данным выражением, теряется. Т.е. обычно такое выражение содержит операцию присваивания, хотя это по синтаксису не обязательно.

A = 0; x = (a > b ? a: b); cnt++;

Условный оператор (if)

Синтаксис

If (<условие>) <оператор1>

Здесь <условие> — это логическое выражение, т.е. выражение, возвращающее true или false. Как видно из синтаксиса, часть else вляется необязательной. После if и после else стоит по одному оператору. Если нужно поместить туда несколько операторов, то нужно поставить блок . Блок начинается с "{" и заканчивается "}".

В Java принято блок ставить всегда, даже если после if или else стоит один оператор.

If (a > b) { x = a; } else { x = b; } if (flag) { flag = false; init(); }

В последнем примере flag — логическая переменная или поле, init() -метод, вызываемый, если флаг равен true (говорят, "если flag установлен").

Оператор return (уже рассматривали)

Оператор цикла по предусловию (while)

Синтаксис

While (<условие>) <оператор>

Как и в случае оператора if, в Java принято <оператор> заключать в фигурные скобки.

Int i = 0; while (more) { x /= 2; more = (++i < 10); }

В этом примере more должна быть логической переменной или полем, x — некоторой арифметической переменной или полем. Цикл выполняется 10 раз.

Оператор цикла по постусловию (do while)

Синтаксис

Do <оператор> while (<условие>);

Оператор цикла по постусловию отличается от оператора цикла по предусловию только тем, что в нем виток цикла выполняется всегда как минимум один раз, в то время как в операторе по предусловию может не быть ни одного витка цикла (если условие сразу ложно).

Int i = 0; do { x \= 2; more = (++i < 10); } while (more);

Оператор цикла "со счетчиком" (for)

Синтаксис

For (<инициализация>; <условие>; <инкремент>) <оператор>

Заголовок такого цикла содержит три выражения (в простейшем случае). Из наименования оператора можно понять, что он служит для организации цикла со счетчиком. Поэтому выражение <инициализация> выполняется один раз перед первым витком цикла. После каждого витка цикла выполняется выражение <инкремент>, а потом выражение <условие>. Последнее выражение должно быть логическим и служит для задания условия продолжения цикла. Т.е. пока оно истинно, витки цикла будут продолжаться.

Для удобства составления операторов цикла со счетчиком в данной конструкции введено множество расширений.

• <инициализация> может быть не выражением, а описанием с инициализацией типа "int i = 0".
• <инициализация> может быть списком выражений через запятую, например, "i = 0, r = 1" .
• <инкремент> тоже может быть списком выражений, например, "i++, r*=2"
• Все составляющие (<инициализация>, <условие> и <инкремент>) являются необязательными. Для выражения <условие> это означает, что условие считается всегда истинным (т.е. выход из цикла должен быть организован какими-то средствами внутри самого цикла).

Т.е. допустим и такой цикл (бесконечный цикл):

For (;;) { . . . }

For (int i = 0; i < 10; i++) x /=2;

Это самая "экономичная" реализация цикла из предыдущих примеров.

Операторы break и continue

В Java нет операторов goto. Как известно, goto приводит к появлению неструктурированных программ. Операторы break и continue являются структурированными аналогами goto.

Они могут применяться в циклах, а break еще и в операторе выбора (switch). Выполнение оператора break приводит к немедленному завершению цикла. Оператор continue вызывает окончание текущего витка цикла и начало нового. Проверка условия в этом случае все же выполняется, так что continue может вызвать и окончание цикла.

For (int i = 0; ;i++) { if (oddOnly && i%2 == 0) continue; y = (x + 1)/x; if (y — x < 0.001) break; x = y; }

Здесь oddOnly — логическая переменная. Если она установлена, то все витки цикла с четными номерами пропускаются с использованием оператора continue;

Условие окончания цикла в данном примере проверяется в середине цикла и, если оно выполнено, то цикл прекращается при помощи оператора break.

При вложенных циклах операторы break и continue могут относиться не только к тому циклу, в котором они расположены, но и к охватывающему циклу. Для этого охватывающий оператор цикла должен быть помечен меткой, которая должна быть указана в операторе break или continue. Например,

Lbl: while (...) { . . . for (...) { . . . if (...) break lbl; } . . . }

Здесь оператор break вызовет прекращение как цикла for, так и while.

Оператор выбора (switch)

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

Синтаксис

Switch (<выражение>) { case <константа1>: <операторы1> case <константа2>: <операторы2> . . . }

Выражение должно выдавать целочисленное или символьное значение, константы должны быть того же типа, что и значение этого выражения.

Элементы "case <константа>:" являются метками перехода, если значение выражения совпадает с константой, то будет осуществлен переход на эту метку. Если значение выражения не совпадает ни с одной из констант, то все зависит от наличия фрагмента default. Если он есть, то переход происходит на метку default, если его нет, то весь оператор switch пропускается.

• В операторе switch фрагменты case не образуют какие-либо блоки. Если после последнего оператора данного case-фрагмента стоит следующий case, то выполнение будет продолжено, начиная с первого оператора этого case-фрагмента.
• В силу этого в операторе switch обычно применяется оператор break. Он ставится в конце каждого case-фрагмента.

Пример (файл SymbolTest.java)

Рассмотрим демонстрационную программу, в которой использованы операторы for и switch.

Эта программа генерирует случайным образом 100 символов латинского алфавита и классифицирует их как "гласные", "согласные" и "иногда гласные". В последнюю категорию отнесены символы "y" и "w".

Public class SymbolTest { public static void main(String args) { for (int i = 0; i < 100; i++) { char c = (char)(Math.random()*26 + "a"); System.out.print(c + ": "); switch (c) { case "a": case "e": case "i": case "o": case "u": System.out.println("гласная"); break; case "y": case "w": System.out.println("иногда гласная"); break; default: System.out.println("согласная"); } } } }

В данном примере есть несколько новых для нас элементов.

• Используется метод random() класса Math. Посмотрим документацию по классу Math и разберемся, что он делает.
• В операторе char c = (char)(Math.random()*26 + "a"); производится сложение арифметического значения с символом. При таком сложении в Java символ преобразуется в число, которое равно коду этого символа.
• В операторе System.out.print(c + ": "); используется не println(...), а print(...). Метод print(...) отличается от println(...) только тем, что не переводит печать на новую строку, так что следующий оператор print(...) или println(...) продолжит печать в той же строке.

Следует также обратить внимание на фрагменты case. Формально здесь 7 таких фрагментов, но 5 из них не содержат никаких операторов. Так что, можно считать, что здесь 2 case-фрагмента, но каждый из них имеет несколько меток case.

Задание на дом

• 1 Изменить SymbolTest.java так, чтобы количество генерируемых символов задавалось параметром вызова программы.
• 2 Написать программу, которая в качестве параметров вызова принимает два числа - длины катетов прямоугольного треугольника, а в качестве результата печатает углы в градусах.

(none)

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. В этом уроке будут описаны различные типы циклов, как циклы могут быть использованы в разработке программ, и для каких целей они используются.

1. Основные арифметические операции

В следующей таблице перечислены основные арифметические операции, применяемые в языке Java:

Рассмотрим некоторые правила работы с арифметическими операциями:

• Выражения вычисляются слева направо, если не добавлены круглые скобки или одни операции имеют более высокий приоритет.
• Операции *, /, и % имеют более высокий приоритет чем + и -.

Пример 1. Арифметические операции над целочисленными значениями

Например, в этом коде, переменные a и b будут иметь разные значения:

Public class BasicIntMath { public static void main(String args) { int a = 4 + 5 - 2 * 3; int b = 4 + (5 - 2) * 3; System.out.println("a = " + a); System.out.println("b = " + b); } }

Результат выполнения:

A = 3 b = 13

• Операция унарного вычитания изменяет знак своего единственного операнда.
• Операция унарного сложения просто возвращает значение своего операнда. Она в принципе не является необходимой, но возможна.

Пример 2. Унарные операции сложения и вычитания

public class UnarySignOperation { public static void main(String args) { double a = -6; double b = +6; System.out.println(a); System.out.println(b); } }

• Когда операция деления выполняется над целочисленным типом данных, ее результат не будет содержать дробный компонент.

Пример 3. Деление целочисленных чисел

public class IntDivision { public static void main(String args) { int a = 16 / 5; System.out.println(a); } }

Результат выполнения этой программы:

• Операнды арифметических операций должны иметь числовой тип. Арифметические операции нельзя выполнять над логическими типами данных, но допускается над типами данных char , поскольку в Java этот тип, по существу, является разновидностью типа int .

Пример 4. Арифметические операции над переменными типа char

public class BasicCharMath1 { public static void main(String args) { char c = "n"; System.out.println(c); System.out.println(c + 1); System.out.println(c / 5); } }

Результат выполнения:

N 111 22

Пример 5. Арифметические операции над переменными типа char

public class BasicCharMath2 { public static void main(String args) { char c1 = "1"; char c2 = "\u0031"; char c3 = 49; System.out.println(c1 + c2 + c3); } }

Результат выполнения:

Оператор деления по модулю — обозначается символом %. Этот оператор возвращает остаток от деления первого числа на второй. При делении целого числа результатом будет тоже целое число.

Пример 6. Деление по модулю

public class DivisionByModule { public static void main(String args) { int a = 6 % 5; double b = 6.2 % 5.0; System.out.println(a); System.out.println(b); } }

Результат выполнения:

1 1.2000000000000002

2. Составные арифметические операции с присваиванием

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

А = а + 4;

B Java эту операцию можно записать следующим образом:

А += 4;

Составные операции с присваиванием позволяют не только уменьшить объем кода, но и позволяют выполнять автоматическое преобразование чего не делают обычные операции.

Пример 5. Составные арифметические операции с присваиванием

public class CompoundOperations { public static void main(String args) { int a = 1; int b = 2; int c = 3; a += 3; b *= 2; c += a * b; System.out.println(a); System.out.println(b); System.out.println(c); } }

Мне кажется, давно уже пора приступить к разработке документа, в котором будет четко оговорено, что граждане могут делать в свое свободное время, а чего они делать не должны.

Из к/ф «Забытая мелодия для флейты»

Все операторы Java можно разделить на четыре группы: арифметические, логиче- ские, побитовые и сравнения. Рассмотрим последовательно каждую группу опе- раторов. Начнем с арифметических. Эти операторы перечислены в табл. 1.2.

Таблица 1.2. Арифметические операторы Java

Оператор	Название	Пояснение
+	Сложение	Бинарный оператор. Результатом команды a+b являет- ся сумма значений переменных a и b
-	Вычитание	Бинарный оператор. Результатом команды a-b являет- ся разность значений переменных a и b
*	Умножение	Бинарный оператор. Результатом команды a*b являет- ся произведение значений переменных a и b
/	Деление	Бинарный оператор. Результатом команды a/b являет- ся частное от деления значений переменных a и b. Для целочисленных операндов по умолчанию выполняется деление нацело
%	Остаток	Бинарный оператор. Результатом команды a%b яв- ляется остаток от целочисленного деления значений переменных a и b
+=	Сложение (упро- щенная форма с присваиванием)	Упрощенная форма оператора сложения с присваива- нием. Команда a+=b является эквивалентом команды a=a+b
-=	Вычитание (упро- щенная форма с присваиванием)	Упрощенная форма оператора вычитания с присваива- нием. Команда a-=b является эквивалентом команды a=a-b
*=	Умножение (упро- щенная форма с присваиванием)	Упрощенная форма оператора умножения с присваи- ванием. Команда a*=b является эквивалентом команды a=a*b
/=	Деление (упро- щенная форма с присваиванием)	Упрощенная форма оператора деления с присваива- нием. Команда a/=b является эквивалентом команды a=a/b
%=	Остаток (упро- щенная форма)	Упрощенная форма оператора вычисления остатка с присваиванием. Команда a%=b является эквивален- том команды a=a%b
++	Инкремент	Унарный оператор. Команда a++ (или ++a) является эквивалентом команды a=a+1
--	Декремент	Унарный оператор. Команда a-- (или --a) является эквивалентом команды a=a-1

Эти операторы имеют некоторые особенности. В первую очередь обращаем вни- мание на оператор деления /. Если операндами являются целые числа, в ка- честве значения возвращается результат целочисленного деления. Рассмотрим последовательность команд:

int a=5,b=2; double x=a/b;

В данном примере переменная x получает значение 2.0, а не 2.5, как можно было бы ожидать. Дело в том, что сначала вычисляется выражение a/b. Поскольку

операнды целочисленные, выполняется целочисленное деление. И только по- сле этого полученное значение преобразуется к формату double и присваивается переменной x.

Для того чтобы при целочисленных операндах выполнялось обычное деление, перед выражением с оператором деления указывается в круглых скобках иден- тификатор типа double (или float). Например, так:

double x=(double)a/b;

Теперь значение переменной x равно 2.5.

В Java, как и в С++, есть группа упрощенных арифметических операторов с присваиванием. Если op - один из операторов сложения, умножения, деления и вычисления остатка, то упрощенная форма этого оператора с присваиванием имеет вид op=. Это тоже бинарный оператор, как и оператор op, а команда вида x op=y является эквивалентом команды x=x op y.

Еще два исключительно полезных унарных оператора - операторы инкремента (++) и декремента (--). Действие оператора декремента сводится к увеличению на единицу значения операнда, а оператор декремента на единицу уменьшает операнд. Другими словами, команда x++ эквивалентна команде x=x+1, а команда x-- эквивалентна команде x=x-1. У операторов инкремента и декремента есть не только представленная здесь постфиксная форма (оператор следует после опе- ранда: x++ или x--), но и префиксная (оператор располагается перед операндом:

X или --x). С точки зрения действия на операнд нет разницы в том, префикс- ная или постфиксная формы оператора использованы. Однако если выражение с оператором инкремента или декремента является частью более сложного вы- ражения, различие в префиксной и постфиксной формах операторов инкремента и декремента существует. Если использована префиксная форма оператора, сна- чала изменяется значение операнда, а уже после этого вычисляется выражение. Если использована постфиксная форма оператора, сначала вычисляется выраже- ние, а затем изменяется значение операнда. Рассмотрим небольшой пример:

В этом случае после выполнения команд переменная n будет иметь значение 11, а переменная m - значение 10. На момент выполнения команды m=n++ значение переменной n равно 10. Поскольку в команде m=n++ использована постфиксная форма оператора инкремента, то сначала выполняется присваивание значения переменной m, а после этого значение переменной n увеличивается на единицу.

Иной результат выполнения следующих команд:

Обе переменные (n и m) в этом случае имеют значение 11. Поскольку в команде m=++n использована префиксная форма инкремента, сначала на единицу увели- чивается значение переменной n, а после этого значение переменной n присваи- вается переменной m.

Следующую группу образуют логические операторы. Операндами логических операторов являются переменные и литералы типа boolean. Логические опера- торы Java перечислены в табл. 1.3.

Таблица 1.3. Логические операторы Java

Оператор	Название	Пояснение
&	Логическое И	Бинарный оператор. Результатом операции A&B явля- ется true, если значения обоих операндов равны true. В противном случае возвращается значение false
&&	Сокращенное логическое И	Бинарный оператор. Особенность оператора, по срав- нению с оператором &, состоит в том, что если значе- ние первого операнда равно false, то значение второго операнда не проверяется
|	Логическое ИЛИ	Бинарный оператор. Результатом операции A|B являет- ся true, если значение хотя бы одного операнда равно true. В противном случае возвращается значение false
||	Сокращенное логическое ИЛИ	Бинарный оператор. Особенность оператора, по срав- нению с оператором |, состоит в том, что если значе- ние первого операнда равно true, то значение второго операнда не проверяется
^	Исключающее ИЛИ	Бинарный оператор. Результатом операции A^B являет- ся true, если значение одного и только одного опе- ранда равно true. В противном случае возвращается значение false
!	Логическое отрицание	Унарный оператор. Результатом команды!A является true, если значение операнда A равно false. Если зна- чение операнда A равно true, результатом команды!A является значение false

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

В табл. 1.4 перечислены операторы сравнения, используемые в Java.

Таблица 1.4. Операторы сравнения Java

Оператор	Название	Пояснение
<	Меньше	Результатом операции Aменьше значения операнда B. В противном случае значением является false
<=	Меньше или равно	Результатом операции A<=B является значения true, если значение операнда A не больше значения операн- да B. В противном случае значением является false
>	Больше	Результатом операции A>B является значения true, если значение операнда A больше значения операнда B. В противном случае значением является false
>=	Больше или равно	Результатом операции A>=B является значения true, если значение операнда A не меньше значения опе- ранда B. В противном случае значением является false
!=	Не равно	Результатом операции A!=B является значения true, если операнды A и B имеют разные значения. В про- тивном случае значением является false

Операторы сравнения обычно используются совместно с логическими операто- рами.

Для понимания принципов работы поразрядных операторов необходимо иметь хотя бы элементарные познания о двоичном представлении чисел. Напомним читателю некоторые основные моменты.

‰ В двоичном представлении позиционная запись числа содержит нули и еди- ницы.

‰ Старший бит (самый первый слева) определяет знак числа. Для положитель- ных чисел старший бит равен нулю, для отрицательных - единице.

‰ Перевод из двоичной системы счисления положительного числа с позицион-

ной записью

bnbn -1...b 2b 1b 0

(bi могут принимать значения 0 или 1, старший

бит для положительных чисел bn = 0) в десятичную выполняется так:

n -1 n

+ ... + bn -12

‰ Для перевода отрицательного двоичного числа в десятичное представление производится побитовое инвертирование кода (об операции побитового ин- вертирования - см. далее), полученное двоичное число переводится в деся- тичную систему, к нему прибавляется единица (и добавляется знак минус).

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

‰ Умножение числа на два эквивалентно сдвигу влево на один бит позиционной записи числа (с заполнением первого бита нулем).

Побитовые операторы Java описаны в табл. 1.5.

Таблица 1.5. Побитовые операторы Java

Оператор	Название	Пояснение
&	Побитовое И	Бинарный оператор. Логическая операция И приме- няется к каждой паре битов операндов. Результатом является 1, если каждый из двух сравниваемых битов равен 1. В противном случае результат равен 0
|	Побитовое ИЛИ	Бинарный оператор. Логическая операция ИЛИ при- меняется к каждой паре битов операндов. Результатом является 1, если хотя бы один из двух сравниваемых битов равен 1. В противном случае результат равен 0
^	Побитовое ИСКЛЮЧА- ЮЩЕЕ ИЛИ	Бинарный оператор. Логическая операция ИСКЛЮЧАЮЩЕЕ ИЛИ применяется к каждой паре битов операндов. Результатом является 1, если один и только один из двух сравниваемых битов равен 1. В противном случае результат равен 0
~	Побитовое отрицание	Унарный оператор. Выполняется инверсия двоичного кода: 0 меняется на 1, а 1 меняется на 0
>>	Сдвиг вправо	Бинарный оператор. Результатом является число, получаемое сдвигом вправо в позиционном пред- ставлении первого операнда (слева от оператора) на количество битов, определяемых вторым операндом (справа от оператора). Исходное значение перво- го операнда при этом не меняется. Младшие биты теряются, а старшие заполняются дублированием знакового бита
<<	Сдвиг влево	Бинарный оператор. Результатом является число, получаемое сдвигом влево в позиционном представле- нии первого операнда (слева от оператора) на количе- ство битов, определяемых вторым операндом (справа от оператора). Исходное значение первого операнда при этом не меняется. Младшие биты заполняются нулями, а старшие теряются
>>>	Беззнаковый сдвиг вправо	Бинарный оператор. Результатом является число, по- лучаемое сдвигом вправо в позиционном представле- нии первого операнда (слева от оператора) на количе- ство битов, определяемых вторым операндом (справа от оператора). Исходное значение первого операнда при этом не меняется. Младшие биты теряются, а старшие заполняются нулями
&=	Упрощенная форма побито- вого оператора & с присваиванием	Команда вида A& A=A&B
|=	Упрощенная форма побито- вого оператора | с присваиванием	Команда вида A|=B является эквивалентом команды A=A|B

Оператор	Название	Пояснение
^=	Упрощенная	Команда вида A^=B является эквивалентом команды
форма побито-
вого оператора ^	A=A^B
с присваиванием
>>=	Упрощенная	Команда вида A>>=B является эквивалентом команды
форма побитово-
го оператора >>	A=A>>B
с присваиванием
<<=	Упрощенная	Команда вида A<<=B является эквивалентом команды
форма побитово-
го оператора <<	A=A<
с присваиванием
>>>=	Упрощенная	Команда вида A>>>=B является эквивалентом команды
форма побитово-
го оператора >>>	A=A>>>B
с присваиванием

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

Помимо перечисленных операторов, в Java есть единственный тернарный опе- ратор (у оператора три операнда). Формально оператор обозначается как?:. Синтаксис вызова этого оператора следующий:

условие?значение_1:значение_2

Первым операндом указывается условие - выражение, возвращающее в качестве значения логическое значение. Если значение выражения-условия равно true, в качестве значения тернарным оператором возвращается значение_1. Если зна- чением выражения-условия является false, тернарным оператором в качестве значения возвращается значение_2.

Несколько замечаний по поводу оператора присваивания (оператор =). В Java оператор присваивания возвращает значение. Команда вида x=y выполняется следующим образом. Сначала вычисляется выражение y, после чего это выра- жение приводится к типу переменной x и затем записывается в эту переменную. Благодаря тому, что, в отличие от других операторов с равными приоритетами, присваивание выполняется справа налево, в Java допустимыми являются ко- манды вида x=y=z. В этом случае значение переменной z присваивается сначала переменной y, а затем значение переменной y присваивается переменной x.

Еще одно замечание касается упрощенных форм операторов с присваиванием, то есть операторов вида op=. Хотя утверждалось, что команда вида A op=B эк- вивалента команде A=A op B, это не совсем так. При выполнении команды вида A op=B сначала вычисляется выражение A op B, затем полученное значение при- водится к типу переменной A и только после этого присваивается переменной A. Поскольку приведение к типу переменной A выполняется, фактически, явно, а в команде A=A op B приведение типов неявное, может проявиться разница

в использовании полной и упрощенной форм команд присваивания. Рассмо- трим простой пример:

// Правильно: a+=20;

// Неправильно: a=a+b;

В данном случае команда a+=20 является корректной, а команда a=a+b - нет. В первом случае литерал 20 типа int «насильственно» приводится к типу byte в силу особенностей оператора +=. Во втором случае результат вычисления вы- ражения a+b автоматически расширяется до типа int, а автоматическое приведе- ние типа int к типу byte запрещено.

Напоследок приведем в табл. 1.6 данные о приоритете различных операторов в Java.

Таблица 1.6. Приоритеты операторов в Java

Приоритет	Операторы
	Круглые скобки (), квадратные скобки и оператор «точка»
	Инкремент ++, декремент --, отрицания ~ и!
	Умножение *, деление / и вычисление остатка %
	Сложение + и вычитание -
	Побитовые сдвиги >>, << и >>>
	Больше >, больше или равно >=, меньше или равно <= и меньше <
	Равно == и неравно!=
	Побитовое И &
	Побитовое исключающее ИЛИ ^
	Побитовое ИЛИ |
	Логическое И &&
	Логические ИЛИ ||
	Тернарный оператор?:
	Присваивание = и сокращенные формы операторов вида op=

Операторы равных приоритетов (за исключением присваивания) выполняются слева направо. В случаях когда возникают сомнения в приоритете операторов и последовательности вычисления выражений, рекомендуется использовать круглые скобки.

Операторы в языке 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. Теперь вы можете сконструировать любое выражение с различными типами данных . В следующей главе познакомимся с конструкциями ветвления, организацией циклов и научимся управлять выполнением программы.