代入演算子
変数に定数、別の変数、または式 (演算子記号で区切られた変数および/または定数) の値を割り当てることは代入操作と呼ばれ、次のように 「 = 」記号で示されます。x = 3; y = x; z = x;
Java では、次のように 1 つの式で代入演算子を複数回使用できます。
x1 = x2 = x3 = 0;
この操作は右から左へ、つまり右から左へ実行されます。最初に変数x3
に の値が割り当てられ0
、次に変数に変数( )x2
の値が割り当てられ、最後に変数に変数( )の値が割り当てられます。引数が数値である演算記号は、引数が 1 つである単項 (単項) 演算記号と、引数が 2 つある二項 (バイナリ) の 2 つのカテゴリに分類されます。 x3
0
x1
x2
0
単項演算
Java では次のものが定義されていますунарные операции
。- 単項マイナス "
-
" – 数値または式の符号を反対に変更します。 - 単項プラス "
+
" – 数値または式に対してアクションを実行しません。 - ビット単位の補数 "
~
" (整数のみ) – 数値フィールドのすべてのビットを反転します (0 を 1 に、1 を 0 に変更します)。 - インクリメント "
++
" (整数のみ) – 変数の値を 1 増やします。 - decrement "
--
" (整数のみ) – 変数の値を 1 ずつ減らします。
+
単項演算子「 」と「 」の例
-
:
int i = 3, j, k;
j= -i; // j = -3
k = +i; // k = 3
ビットの補数演算の例:
int a = 15;
int b;
b = ~a; // b = -16
数値
a
と は
b
タイプの数値です
int
。つまり、コンピュータ内部では 32 ビットの符号付き 2 進整数として表現されるため、数値の 2 進表現は次のように
a
なります。
b
a = 00000000 00000000 00000000 00001111
b = 11111111 11111111 11111111 11110000
この表現からわかるように、数値 a のすべての 0 ビットは数値 a の 1 ビットに変更され
b
、a の 1 ビットは 0 ビットに変更されます。数値の 10 進表現
b
は です
–16
。インクリメント演算記号とデクリメント演算記号は、変数の前後どちらにでも配置できます。
これらのオプションは、それぞれ、これらの操作のプレフィックス表記および
ポストフィックス表記と呼ばれます。演算子のサインイン接頭辞表記は、式が評価された
後にオペランドの値を返します。後置表記を使用すると、演算記号は
最初にオペランドの値を返し、次に増分または減分を計算します。次に例を示します。
int x = 1, y, z;
y = ++x;
z=x++;
Переменная
y
будет присвоено meaning
2
, поскольку сначала meaning
x
будет увеличено на
1
, а затем результат будет присвоен переменной
y
. Переменной
z
будет присвоено meaning
1
, поскольку сначала переменной
z
будет присвоено meaning, а затем meaning
x
будет увеличено на
1
. В обоих случаях новое meaning переменной
x
будет равно
2
. Следует отметить, что в Java, в отличие от языка C, операции декремента и инкремента могут применяться и к вещественным переменным (типа
float
и
double
).
Бинарные знаки операций подразделяются на операции с числовым результатом и операции сравнения, результатом которых является булевское meaning.
Арифметические бинарные операции
В Java определены следующие арифметические бинарные операции:- сложение "
+
"; - вычитание "
-
"; - умножение "
*
"; - деление "
/
"; - вычисление остатка от деления целых чисел "
%
" (возвращает остаток от деления первого числа на второе, причем результат будет иметь тот же знак, что и делимое), например, результат операции5%3
будет equals2
, а результат операции (-7)%(-4) будет equals-3
. В Java операция может использоваться и для вещественных переменных (типаfloat
ordouble
).
int x = 7, x1, x2, x3, x4, x5;
x1 = x +10; // x1 = 17
x2 = x – 8; // x2 = -1
x3 = x2 * x; // x3 = -7
x4 = x/4; // x4 = 1 (при делении целых чисел
// дробная часть отбрасывается)
x5 = x%4 // x5 = 3 (остаток от деления
// 7 на 4)
Побитовые операции
Побитовые операции
рассматривают исходные числовые значения How поля битов и выполняют над ними следующие действия:- установка бита в i-ой позиции поля результата в
1
, если оба бита в i-ых позициях операндов равны1
, or в0
в противном случае –побитовое И
("&
"); - установка бита в i-ой позиции поля результата в
1
, если хотя бы один бит в i-ых позициях операндов equals1
, or в0
в противном случае –побитовое ИЛИ
("|
"); - установка бита в i-ой позиции поля результата в
1
, если биты в i-ых позициях операндов не равны друг другу, or в0
в противном случае –побитовое исключающее ИЛИ
("^
"); - сдвиг влево битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) –
побитовый сдвиг влево с учетом знака
"<<
"; - сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) –
побитовый сдвиг вправо с учетом знака
">>
"; - сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом также сдвигается) –
побитовый сдвиг вправо без учета знака
">>>
".
-
Побитовое И
int x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z = x & y; // z=80: 00000000 00000000 00000000 01010000
-
Побитовое ИЛИ
int x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z =x | y; // z = 126: 00000000 00000000 00000000 01111110
-
Побитовое исключающее ИЛИ
int x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z =x ^ y; // z = 46: 00000000 00000000 00000000 00101110
-
Сдвиг влево с учетом знака
int x = 31, z; // x: 00000000 00000000 00000000 00011111 z = x << 2; // z = 124: 00000000 00000000 00000000 01111100
-
Сдвиг вправо с учетом знака
int x = -17, z; // x: 11111111 11111111 11111111 11101111 z = x >> 2; // z = -5: 11111111 11111111 11111111 11111011
-
Сдвиг вправо без учета знака
int x = -17, z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2; // z = 1073741819 // z: 00111111 11111111 11111111 11111011
Комбинированные операции
В Java для бинарных арифметических операций можно использовать комбинированные (составные) знаки операций:идентификатор операция = выражение
Это эквивалентно следующей операции:
идентификатор = идентификатор операция выражение
Примеры:
- Выражение
x += b
означаетx = x + b
. - Выражение
x -= b
означаетx = x - b
. - Выражение
x *= b
означаетx = x * b
. - Выражение
x /= b
означаетx = x / b
. - Выражение
x %= b
означаетx = x % b
. - Выражение
x &= b
означаетx = x & b
. - Выражение
x |= b
означаетx = x | b
. - Выражение
x ^= b
означаетx = x ^ b
. - Выражение
x <<= b
означаетx = x << b
. - Выражение
x >>= b
означаетx = x >> b
. - Выражение
x >>>= b
означаетx = x >>> b
.
Операции сравнения
В Java определены следующие операции сравнения:- "
==
" (равно), "!=
" (не равно), - "
>
" (больше), ">=
" (больше or равно), - "
<
" (меньше) "<=
" (меньше or равно)
=
" при сравнении двух величин либо вызывает ошибку при компиляции, либо приводит к неверному результату.
Примеры операций сравнения:
boolean isEqual, isNonEqual, isGreater,
isGreaterOrEqual, isLess, isLessOrEqual;
int x1 = 5, x2 = 5, x3 = 3, x4 = 7;
isEqual = x1 == x2; // isEqual = true
isNonEqual = x1 != x2; // isNonEqual = false
isGreater = x1 > x3; // isGreater = true
// isGreaterOrEqual = true
isGreaterOrEqual = x2 >= x3;
isLess = x3 < x1; // isLess = true
isLessOrEqual = x1 <= x3; // isLessOrEqual = false
Булевские операции
Булевские операции выполняются над булевскими переменными и их результатом также является meaning типа boolean. В Java определены следующие булевские операции:- отрицание
"!"
– заменаfalse
наtrue
, or наоборот; - операция
И
"&"
– результат equalstrue
, только, если оба операнда равныtrue
, иначе результат –false
; - операция
ИЛИ
"|
" – результат equalstrue
, только, если хотя бы один из операндов equalstrue
, иначе результат –false
. - операция исключающее
ИЛИ
"^
" – результат equalstrue
, только, если операнды не равны друг другу, иначе результат –false
.
&
", "
|
" и "
^
" можно, также How и соответствующие побитовые операции использовать в составных операциях присваивания: "
&=
", "
|=
" и "
^=
" Кроме того, к булевским операндам применимы операции "
==
" (равно) и "
!=
" (не равно). Как видно из определения операций ИЛИ и И, операция ИЛИ приводит к результату
true
, когда первый операнд equals
true
, независимо от значения второго операнда, а операция И приводит к результату
false
, когда первый операнд equals
false
, независимо от значения второго операнда. В Java определены еще две булевские операции: вторые версии булевских операций И и ИЛИ, известные How укороченные (short-circuit) логические операции: укороченное И "
&&
" и укороченное ИЛИ "
||
". При использовании этих операций второй операнд вообще не будет вычисляться, что полезно в тех случаях, когда правильное функционирование правого операнда зависит от того, имеет ли левый операнд meaning
true
or
false
.
Примеры булевских операций:
boolean isInRange, isValid, isNotValid,
isEqual, isNotEqual;
int x = 8;
isInRange = x > 0 && x < 5; // isInRange = false
isValid = x > 0 || x > 5; // isValid = true
isNotValid = !isValid; // isNotValid = false
isEqual = isInRange == isValid; // isEqual = false
// isNotEqual = true
isNotEqual = isInRange != isValid
Условная операция
Условная операция записывается в формевыражение-1?выражение-2:выражение-3
. При этом сначала вычисляется выражение
выражение-1
, которое должно дать булевское meaning, а затем, если
выражение-1
имеет meaning
true
, вычисляется и возвращается
выражение-2
How результат выполнения операции, либо (если
выражение-1
имеет meaning
false
), вычисляется и, How результат выполнения операции, возвращается
выражение-3
.
Пример условной операции:
x=n>1?0:1;
Переменной x будет присвоено meaning
0
, если
n>1
(выражение
n>1
имеет meaning
true
) or
1
, если
n≤1
(выражение
n>1
имеет meaning
false
).
Старшинство операций
Операции в выражениях выполняются слева направо, однако, в соответствии со своим приоритетом. Так операции умножения в выраженииy = x +z*5;
будет выполнена раньше, чем операция сложения, поскольку приоритет операции умножения выше, чем приоритет операции сложения. Приоритеты операций (в порядке уменьшения приоритета) в Java приведены в табл. 1.
![Java のプリミティブ型の操作 - 2](https://cdn.javarush.com/images/article/7bb245f1-14f4-4c3d-bf37-8a4f533c60e3/1024.jpeg)
y = (x +z)*5;
то сначала будет выполнена операция сложения, а затем операция умножения. Иногда скобки используют просто для того, чтобы сделать выражение более читаемым, например:
(x > 1) && (x <= 5);
Преобразование и приведение типов при выполнении операций
В операции присваивания и арифметических выражениях могут использоваться литералы, переменные и выражения разных типов, например:double y;
byte x;
y = x + 5;
В этом примере выполняется операция сложения переменной
x
типа
byte
и литерала
5
(типа
int
) и результат присваивается переменной
y
типа
double
. В Java, How и в языке C, преобразования типов при вычислении выражений могут выполняться автоматически, либо с помощью оператора приведения типа. Однако правила приведения типов несколько отличаются от правил языка C, и в целом являются более строгими, чем в языке C. При выполнении операции присваивания преобразование типов происходит автоматически, если происходит
расширяющее преобразование (widening conversion) и
два типа совместимы. Расширяющими преобразованиями являются преобразования
byte®
short®
int®
long®
float®
double. Для расширяющих преобразований числовые типы, включая целый и с плавающей точкой, являются совместимыми друг с другом. Однако числовые типы не совместимы с типами
char
и
boolean
. Типы
char
и
boolean
не совместимы также и друг с другом. В языке Java выполняется автоматическое преобразование типов также и при сохранении литеральной целочисленной константы (которая имеет по умолчанию тип
int
) в переменных типа
byte
,
short
or
long
(однако если литерал имеет meaning вне диапазона допустимых значений для данного типа, выдается сообщение об ошибке: возможная потеря точности). Если преобразование является сужающим (narrowing conversion), т. е. выполняется преобразование
byte
¬
short
¬
char
¬
int
¬
long
¬
float
¬
double
, то такое преобразование может привести к потере точности числа or к его искажению. Поэтому при сужающих преобразованиях при компиляции программы выводится диагностическое сообщение о несовместимости типов и файлы классов не создаются. Такое сообщение будет выдано и при попытке преобразование выражений типа
byte
or
short
в переменную типа
char
. Если все же необходимо выполнить такие преобразования, используется операция приведения (cast) типа, которая имеет следующий формат: (
тип-преобразования)
meaning, где
тип-преобразования определяет тип, в который необходимо преобразовать заданное
meaning, например, в результате выполнения операторов:
byte x = 71;
char symbol = (char) x;
переменная
symbol
получит meaning '
G
'. Если meaning с плавающей точкой присваивается целому типу, то (если meaning с плавающей точкой имеет дробную часть) при явном преобразовании типа происходит также
усечение (truncation) числа. Так, в результате выполнения оператора
int x = (int) 77.85;
переменная x получит meaning
77
. Если же присваиваемое meaning лежит вне диапазона
типа-преобразования, то результатом преобразования будет остаток от деления значения на модуль диапазона присваиваемого типа (для чисел типа
byte
модуль диапазона будет equals
256
, для
short – 65536
, для
int – 4294967296
и для
long – 18446744073709551616
). Например, в результате выполнения оператора
byte x = (byte) 514;
переменная x получит meaning
2
. При преобразовании целых or вещественных чисел в данные типа
char
, преобразование в символ происходит, если исходное число лежит в диапазоне от 0 до 127, иначе символ получает meaning '
?
'. При выполнении арифметических и побитовых преобразований все значения
byte
и
short
, а также
char
расширяются до
int
, (при этом в вычислениях для
char
используется числовое meaning codeа символа) затем, если хотя бы один операнд имеет тип
long
, тип целого выражения расширяется до
long
. Если один из операндов имеет тип
float
, то тип полного выражения расширяется до
float
, а если один из операндов имеет тип
double
, то тип результата будет
double
. Так, если объявлены переменные
byte a, c;
short b;
то в выражении
a + b*c – 15L + 1.5F + 1.08 - 10;
сначала, перед вычислением
a + b*c
значения переменных будут расширены до
int
, затем, поскольку константа
15
имеет тип
long
, перед вычитанием результат вычисления будет увеличен до
long
. После этого, поскольку литерал
1.5
имеет тип
float
перед сложением с этим литералом результат вычисления
a + b*c – 15L
будет расширен до
float
. Перед выполнением сложения с числом
1.08
результат предыдущих вычислений будет расширен до
double
(поскольку вещественные константы по умолчанию имеют тип
double
) и, наконец, перед выполнением последнего сложения литерал 10 (по умолчанию
int
) будет расширен до
double
. Таким образом, результат вычисления выражения будет иметь тип
double
. Автоматические расширения типов (особенно расширения
short
и
byte
до
int
) могут вызывать плохо распознаваемые ошибки во время компиляции. Например, в операторах:
byte x = 30, y =5;
x = x + y;
перед выполнением сложения meaning переменных
x
и
y
будет расширено до
int
, а затем при выполнении попытки присвоения результата вычисления типа
int
переменной типа
byte
будет выдано сообщение об ошибке. Whatбы этого избежать надо использовать во втором операторе явное преобразование типов:
x = (byte) (x + y);
Выражение
x + y
необходимо заключит в скобки потому, что приоритет операции приведения типа, заключенной в скобки, выше, чем приоритет операции сложения. Кстати, если записать второй оператор в виде:
x += y;
то messages об ошибке не будет.
Ссылка на первоисточник: Операции над примитивными типами в Java
GO TO FULL VERSION