Təyinat operatoru
Dəyişənə sabitin, başqa dəyişənin və ya ifadənin (operator işarələri ilə ayrılmış dəyişənlər və/yaxud sabitlər) qiymətinin təyin edilməsi təyinat əməliyyatı adlanır və “ = ” işarəsi ilə göstərilir , məsələn:x = 3; y = x; z = x;
Java-da təyin operatorunu bir ifadədə bir neçə dəfə istifadə etmək mümkündür, məsələn:
x1 = x2 = x3 = 0;
Bu əməliyyat sağdan sola aparılır, yəni. əvvəlcə dəyişənə , sonra dəyişənə dəyişənə ( ) dəyəri təyin edilir x3
və nəhayət dəyişənə ( ) dəyəri təyin edilir . Arqumentləri ədədlərdən ibarət olan əməliyyat işarələri iki kateqoriyaya bölünür: bir arqumentli unar (unar) əməliyyat işarələri və iki arqumentli ikili (ikilik) işarələr. 0
x2
x3
0
x1
x2
0
Unar əməliyyatlar
Java-da aşağıdakılar müəyyən edilirунарные операции
:- unar minus "
-
" – ədədin və ya ifadənin işarəsini əksinə dəyişir; - unary plus "
+
" – rəqəm və ya ifadə üzərində heç bir hərəkət etmir; - bitwise tamamlayıcı "
~
" (yalnız tam ədədlər üçün) – ədəd sahəsinin bütün bitlərini çevirir (0-dan 1-ə və 1-dən 0-a dəyişir); - artım "
++
" (yalnız tam ədədlər üçün) – dəyişənin qiymətini 1 artırır; - azalma "
--
" (yalnız tam ədədlər üçün) – dəyişənin dəyərini 1 azaldır.
+
" və "
-
" nümunələri:
int i = 3, j, k;
j= -i; // j = -3
k = +i; // k = 3
Bitin tamamlama əməliyyatına misal:
int a = 15;
int b;
b = ~a; // b = -16
Nömrələr
a
və
b
tipli ədədlərdir
int
, yəni. kompüter daxilində 32 bit uzunluğunda işarəli ikili tam ədədlər kimi təmsil olunur, buna görə də ədədlərin ikili təsviri belə görünür
a
:
b
a = 00000000 00000000 00000000 00001111
b = 11111111 11111111 11111111 11110000
Bu təsvirdən göründüyü kimi, a nömrəsindəki bütün sıfır bitlər a nömrəsindəki bir bitə
b
, a-dakı bir bit isə sıfır bitə dəyişdirilir. Ədədin onluq
b
təmsili
–16
. Artırma və azaltma əməliyyatı işarələri dəyişəndən əvvəl və ya sonra yerləşdirilə bilər.
Bu seçimlər bu əməliyyatlar üçün müvafiq olaraq prefiks və
postfiks qeydləri adlanır . Giriş operatoru prefiks notasiyası ifadə qiymətləndirildikdən
sonra öz operandının dəyərini qaytarır . Postfiks notasiyası ilə əməliyyat işarəsi
əvvəlcə öz operandının dəyərini qaytarır və yalnız bundan sonra artım və ya azalmanı hesablayır, məsələn:
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.
Круглые скобки повышают старшинство операций, которые находятся внутри них. Так, если в приведенное выше выражение вставить скобки:
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