Что значит s в java. Операции над примитивными типами в Java

Укороченные (short-circuit) логические операторы && и || предназначаются для логических AND (И) и OR (ИЛИ) операций над выражениями типа boolean . Заметьте, что для XOR (исключающее ИЛИ) операции не существует укороченного логического оператора.

Укороченные логические операторы похожи на операторы & и |, но в отличие от них применяются только к выражениям типа boolean и никогда не применяются к интегральным типам. Тем не менее, && и || обладают замечательным свойством: они укорачивают вычисление выражения, если результат может быть дедуцирован из части выражения (чуть позже я поясню это на примерах). Благодаря этому свойству, операторы && и || широко используются для обработки null-выражений. Они также помогают увеличить эффективность всей программы.

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

• выражение с AND оператором ложно (false ), если значение хотя бы одного из его операндов ложно;
• выражение с OR оператором истинно (true ), если значение хотя бы одного из его операндов истинно.

Иными словами:

• false AND X = false
• true OR X = true

То есть, если левый операнд AND выражения ложен, то и всё выражение ложно, вне зависимости от значения правого операнда. То есть при ложном левом операнде нет нужны вычислять значение правого операнда. Аналогичным образом, если левый операнд OR выражения истиннен, то истинно и всё выражения, вне зависимости от значения правого операнда, которое, следовательно, нам не нужно вычислять.

Рассмотрим пример кода, который выводит сообщение 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

Логические операторы работают только с операндами типа boolean . Все логические операторы с двумя операндами объединяют два логических значения, образуя результирующее логическое значения. Не путайте с .

Таблица логических операторов в Java

Логические операторы & , | , ^ действуют применительно к значениям типа boolean точно так же, как и по отношению к битам целочисленных значений. Логический оператор ! инвертирует (меняет на противоположный) булево состояние: !true == false и !false == true .

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

A	B	A | B	A & B	A ^ B	!A
false	false	false	false	false	true
true	false	true	false	true	false
false	true	true	false	true	true
true	true	true	true	false	false

Сокращённые логические операторы

Кроме стандартных операторов AND (&) и OR (|) существуют сокращённые операторы && и || .

Если взглянуть на таблицу, то видно, что результат выполнения оператора OR равен true true , независимо от значения операнда B. Аналогично, результат выполнения оператора AND равен false , когда значение операнда A равно false , независимо от значения операнда B. Получается, что нам не нужно вычислять значение второго операнда, если результат можно определить уже по первому операнду. Это становится удобным в тех случаях, когда значение правого операнда зависит от значения левого.

Рассмотрим следующий пример. Допустим, мы ввели правило - кормить или не кормить кота в зависимости от числа пойманных мышек в неделю. Причём число мышек зависит от веса кота. Чем больше кот, тем больше он должен поймать мышей.

Кот, прочитавший условие задачи, обиделся на меня. Он заявил, что я отстал от жизни, а на дворе 21 век - мышей можно ловить с помощью мышеловок. Пришлось объяснять ему, что это всего лишь задачка, а не пример из личной жизни.

Int mouse; // число мышек int weight; // вес кота в граммах mouse = 5; weight = 4500; if (mouse != 0 & weight / mouse < 1000) { mInfoTextView.setText("Можно кормить кота"); }

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

Теперь возьмём крайний случай. Кот обленился и не поймал ни одной мышки. Значение переменной mouse будет равно 0, а в выражении есть оператор деления. А делить на 0 нельзя и наша программа закроется с ошибкой. Казалось бы, мы предусмотрели вариант с 0, но Java вычисляет оба выражения mouse != 0 и weight / mouse < 1000 , несмотря на то, что уже в первом выражении возвращается false .

Перепишем условие следующим образом (добавим всего лишь один символ):

If (mouse != 0 && weight / mouse < 1000) { mInfoTextView.setText("Можно кормить кота"); }

Теперь программа работает без краха. Как только Java увидела, что первое выражение возвращает false , то второе выражение с делением просто игнорируется.

Сокращённые варианты операторов AND и OR принято использовать в тех ситуациях, когда требуются операторы булевой логики, а их односимвольные родственники используются для побитовых операций.

Тернарный оператор

В языке Java есть также специальный тернарный условный оператор, которым можно заменить определённые типы операторов if-then-else - это оператор ?:

Тернарный оператор использует три операнда. Выражение записывается в следующей форме:

ЛогическоеУсловие? выражение1: выражение2

Если логическоеУсловие равно true , то вычисляется выражение1 и его результат становится результатом выполнения всего оператора. Если же логическоеУсловие равно false , то вычисляется выражение2 , и его значение становится результатом работы оператора. Оба операнда выражение1 и выражение2 должны возвращать значение одинакового (или совместимого) типа.

Рассмотрим пример, в котором переменной absval присваивается абсолютное значение переменной val .

Int absval, val; val = 5; absval = val < 0 ? -val: val; // выводим число mInfoTextView.setText("" + absval); val = -5; absval = val < 0 ? -val: val; mInfoTextView.setText("" + absval);

Переменной absval будет присвоено значение переменной val , если значение больше или равно нулю (вторая часть выражения). Если значение переменной val отрицательное , то переменной absval присваивается значение переменной, взятое со знаком минус, в результате минус на минус даст плюс, то есть положительно значение. Перепишем код с использованием if-else :

If(val < 0) absval = -val; else absval = val;

Другой пример с тернарным оператором можете посмотреть .

Операторы в 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. Значения логических операторов для двух переменных

В логическом выражении могут использоваться следующие логические операторы : ==, !=,<=,>=,>,<, &&,||,! .

Рассмотрим на примере:

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:

1. Даны 4 числа типа int. Сравнить их и вывести наименьшее на консоль.
2. Вывести на консоль количество максимальных чисел среди этих четырех.
3. Даны 5 чисел (тип int). Вывести вначале наименьшее, а затем наибольшее из данных чисел.
4. Даны имена 2х человек (тип String). Если имена равны, то вывести сообщение о том, что люди являются тезками.
5. Дано число месяца (тип int). Необходимо определить время года (зима, весна, лето, осень) и вывести на консоль.

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