מפעיל מטלות
הקצאת ערך למשתנה של קבוע, משתנה אחר או ביטוי (משתנים ו/או קבועים המופרדים על ידי סימני אופרטור) נקראת פעולת הקצאה והיא מסומנת בסימן " = ", למשל:x = 3; y = x; z = x;
ב-Java, ניתן להשתמש באופרטור ההקצאה מספר פעמים בביטוי בודד, למשל:
x1 = x2 = x3 = 0;
פעולה זו מתבצעת מימין לשמאל, כלומר. תחילה x3
מוקצה למשתנה הערך של 0
, לאחר מכן למשתנה x2
מוקצה הערך של משתנה x3
( 0
), ולבסוף למשתנה x1
מוקצה ערך המשתנה x2
( 0
). סימני פעולה שהארגומנטים שלהם הם מספרים מתחלקים לשתי קטגוריות: סימני פעולה אונריים (אנריים) עם ארגומנט אחד ובינאריים (בינאריים) עם שני ארגומנטים.
פעולות לא חוקיות
הדברים הבאים מוגדרים ב-Javaунарные операции
:- unary minus "
-
" - משנה את הסימן של מספר או ביטוי להפך; - unary plus "
+
" – אינו מבצע פעולות כלשהן על מספר או ביטוי; - השלמה סיבית "
~
" (עבור מספרים שלמים בלבד) - הופך את כל הביטים של שדה המספרים (משנה 0 ל-1 ו-1 ל-0); - increment "
++
" (עבור מספרים שלמים בלבד) - מגדיל את הערך של המשתנה ב-1; - הפחתה "
--
" (עבור מספרים שלמים בלבד) - מקטין את הערך של המשתנה ב-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 סיביות, כך שהייצוג הבינארי של מספרים
a
ייראה
b
כך:
a = 00000000 00000000 00000000 00001111
b = 11111111 11111111 11111111 11110000
כפי שניתן לראות מהייצוג הזה, כל סיביות האפס במספר a משתנות לסיביות אחת במספר a
b
, והסיביות האחת ב-a משתנות לאפס סיביות. הייצוג העשרוני של המספר
b
הוא
–16
. ניתן להציב סימני פעולה של הגדלה והקטנה לפני או אחרי המשתנה. אפשרויות אלו נקראות סימוני
קידומת ופוסט
-תיקון עבור פעולות אלו, בהתאמה. סימון קידומת הכניסה של האופרטור מחזיר את הערך של האופרנד שלו
לאחר הערכת הביטוי. עם סימון postfix, סימן הפעולה מחזיר
תחילה את הערך של האופרנד שלו ורק לאחר מכן מחשב את התוספת או ההפחתה, למשל:
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