JavaRush /Blog Java /Random-PL /Operacje na typach pierwotnych w Javie
articles
Poziom 15

Operacje na typach pierwotnych w Javie

Opublikowano w grupie Random-PL
Większość operacji na typach pierwotnych nie jest wykonywana przy użyciu metod, ale przy użyciu znaków specjalnych zwanych znakami operacji .
Operacje na typach pierwotnych w Javie - 1

Operator przypisania

Nadanie zmiennej wartości stałej, innej zmiennej lub wyrażenia (zmiennych i/lub stałych oddzielonych znakami operatora) nazywa się operacją przypisania i oznacza się je znakiem „ = ”, np.:
x = 3; y = x; z = x;
W Javie możliwe jest wielokrotne użycie operatora przypisania w jednym wyrażeniu, na przykład:
x1 = x2 = x3 = 0;
Operację tę wykonuje się od prawej do lewej, tj. najpierw zmiennej x3przypisuje się wartość 0, następnie zmiennej x2przypisuje się wartość zmiennej x3( 0), a na koniec zmiennej x1przypisuje się wartość zmiennej x2( 0). Znaki operacji, których argumentami są liczby, dzielimy na dwie kategorie: znaki operacji jednoargumentowych (jednoargumentowych) z jednym argumentem i znaki binarne (binarne) z dwoma argumentami.

Operacje jednoargumentowe

W Javie zdefiniowano następujące elementy унарные операции:
  • jednoargumentowy minus „ -” – zmienia znak liczby lub wyrażenia na przeciwny;
  • unary plus " +" – nie wykonuje żadnych akcji na liczbie ani wyrażeniu;
  • uzupełnienie bitowe „ ~” (tylko dla liczb całkowitych) – odwraca wszystkie bity pola liczbowego (zmienia 0 na 1 i 1 na 0);
  • inkrementacja „ ++” (tylko dla liczb całkowitych) – zwiększa wartość zmiennej o 1;
  • dekrementacja " --" (tylko dla liczb całkowitych) – zmniejsza wartość zmiennej o 1.
Przykłady operatorów jednoargumentowych „ +” i „ -”:
int i = 3, j, k;
j= -i; // j = -3
k = +i; // k = 3
Przykład operacji uzupełnienia bitu:
int a = 15;
int b;
b = ~a; // b = -16
Liczby ai bsą liczbami typu int, tj. są reprezentowane w komputerze jako binarne liczby całkowite ze znakiem o długości 32 bitów, więc binarna reprezentacja liczb abędzie bwyglądać następująco:
a = 00000000 00000000 00000000 00001111
b = 11111111 11111111 11111111 11110000
Jak widać z tej reprezentacji, wszystkie bity zerowe liczby a zostają zamienione na jeden bit liczby a b, a bity jedności w a zostają zamienione na bity zerowe. Dziesiętna reprezentacja liczby bto –16. Znaki operacji zwiększania i zmniejszania można umieszczać przed lub po zmiennej. W przypadku tych operacji opcje te nazywane są odpowiednio notacjami przedrostkowymi i przyrostkowymi . Notacja przedrostka logowania operatora zwraca wartość swojego operandu po ocenie wyrażenia. W notacji przyrostkowej znak operacji najpierw zwraca wartość swojego operandu, a dopiero potem oblicza przyrost lub spadek, na przykład:
int x = 1, y, z;
y = ++x;
z=x++;
Переменная y будет присвоено oznaczający 2, поскольку сначала oznaczający x будет увеличено на 1, а затем результат будет присвоен переменной y. Переменной z будет присвоено oznaczający 1, поскольку сначала переменной z будет присвоено oznaczający, а затем oznaczający x будет увеличено на 1. В обоих случаях новое oznaczający переменной x будет равно 2. Следует отметить, что в Java, в отличие от языка C, операции декремента и инкремента могут применяться и к вещественным переменным (типа float и double). Бинарные знаки операций подразделяются на операции с числовым результатом и операции сравнения, результатом которых является булевское oznaczający.

Арифметические бинарные операции

В Java определены следующие арифметические бинарные операции:
  • сложение "+";
  • вычитание "-";
  • умножение "*";
  • деление "/";
  • вычисление остатка от деления целых чисел "%" (возвращает остаток от деления первого числа на второе, причем результат будет иметь тот же знак, что и делимое), например, результат операции 5%3 будет równa się 2, а результат операции (-7)%(-4) будет równa się -3. В Java операция может использоваться и для вещественных переменных (типа float Lub double).
Примеры бинарных арифметических операций:
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)

Побитовые операции

  • Побитовые операции рассматривают исходные числовые значения Jak поля битов и выполняют над ними следующие действия:
  • установка бита в i-ой позиции поля результата в 1, если оба бита в i-ых позициях операндов равны 1, Lub в 0 в противном случае – побитовое И ("&");
  • установка бита в i-ой позиции поля результата в 1, если хотя бы один бит в i-ых позициях операндов równa się 1, Lub в 0 в противном случае – побитовое ИЛИ ("|");
  • установка бита в i-ой позиции поля результата в 1, если биты в i-ых позициях операндов не равны друг другу, Lub в 0 в противном случае – побитовое исключающее ИЛИ ("^");
  • сдвиг влево битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг влево с учетом знака "<<";
  • сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг вправо с учетом знака ">>";
  • сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом также сдвигается) – побитовый сдвиг вправо без учета знака ">>>".
Примеры побитовых операций:
  1. Побитовое И

    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
  2. Побитовое ИЛИ

    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
  3. Побитовое исключающее ИЛИ

    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
  4. Сдвиг влево с учетом знака

    int x = 31, z;
    // x: 00000000 00000000 00000000 00011111
    z = x << 2;
    // z = 124: 00000000 00000000 00000000 01111100
  5. Сдвиг вправо с учетом знака

    int x = -17, z;
    // x: 11111111 11111111 11111111 11101111
    z = x >> 2;
    // z = -5: 11111111 11111111 11111111 11111011
  6. Сдвиг вправо без учета знака

    int x = -17, z;
    // x: 11111111 11111111 11111111 11101111
    z = x >>> 2;
    // z = 1073741819
    // z: 00111111 11111111 11111111 11111011

Комбинированные операции

В Java для бинарных арифметических операций можно использовать комбинированные (составные) знаки операций: идентификатор операция = выражение Это эквивалентно следующей операции: идентификатор = идентификатор операция выражение Примеры:
  1. Выражение x += b означает x = x + b.
  2. Выражение x -= b означает x = x - b.
  3. Выражение x *= b означает x = x * b.
  4. Выражение x /= b означает x = x / b.
  5. Выражение x %= b означает x = x % b.
  6. Выражение x &= b означает x = x & b.
  7. Выражение x |= b означает x = x | b.
  8. Выражение x ^= b означает x = x ^ b.
  9. Выражение x <<= b означает x = x << b.
  10. Выражение x >>= b означает x = x >> b.
  11. Выражение x >>>= b означает x = x >>> b.

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

В Java определены следующие операции сравнения:
  • "==" (равно), "!=" (не равно),
  • ">" (больше), ">=" (больше Lub равно),
  • "<" (меньше) "<=" (меньше Lub равно)
имеют два операнда и возвращают булевское oznaczający, соответствующее результату сравнения ( false Lub true). Следует обратить внимание, что при сравнении двух величин на równa sięство в Java, Jak и в C и в C++, используются символы " ==" (два идущих без пробела друг за другом знака równa sięства), в отличие от оператора присваивания, в котором используется символ " =". Использование символа " =" при сравнении двух величин либо вызывает ошибку при компиляции, либо приводит к неверному результату. Примеры операций сравнения:
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

Булевские операции

Булевские операции выполняются над булевскими переменными и их результатом также является oznaczający типа boolean. В Java определены следующие булевские операции:
  • отрицание "!" – замена false на true, Lub наоборот;
  • операция И "&" – результат równa się true, только, если оба операнда равны true, иначе результат – false;
  • операция ИЛИ "|" – результат równa się true, только, если хотя бы один из операндов równa się true, иначе результат – false.
  • операция исключающее ИЛИ "^" – результат równa się true, только, если операнды не равны друг другу, иначе результат – false.
Операции " &", " |" и " ^" можно, также Jak и соответствующие побитовые операции использовать в составных операциях присваивания: " &=", " |=" и " ^=" Кроме того, к булевским операндам применимы операции " ==" (равно) и " !=" (не равно). Как видно из определения операций ИЛИ и И, операция ИЛИ приводит к результату true, когда первый операнд równa się true, незави­симо от значения второго операнда, а операция И приводит к результату false, когда первый операнд równa się false, независимо от значения второго операнда. В Java определены еще две булевские операции: вторые версии булевских операций И и ИЛИ, известные Jak укороченные (short-circuit) логические операции: укороченное И " &&" и укороченное ИЛИ " ||". При использовании этих операций второй операнд вообще не будет вычисляться, что полезно в тех случаях, когда правильное функционирование правого операнда зависит от того, имеет ли левый операнд oznaczający true Lub 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, которое должно дать булевское oznaczający, а затем, если выражение-1 имеет oznaczający true, вычисляется и возвращается выражение-2 Jak результат выполнения операции, либо (если выражение-1 имеет oznaczający false), вычисляется и, Jak результат выполнения операции, возвращается выражение-3. Пример условной операции:
x=n>1?0:1;
Переменной x будет присвоено oznaczający 0, если n>1 (выражение n>1 имеет oznaczający true) Lub 1, если n≤1 (выражение n>1 имеет oznaczający false).

Старшинство операций

Операции в выражениях выполняются слева направо, однако, в соответствии со своим приоритетом. Так операции умножения в выражении
y = x +z*5;
будет выполнена раньше, чем операция сложения, поскольку приоритет операции умножения выше, чем приоритет операции сложения. Приоритеты операций (в порядке уменьшения приоритета) в Java приведены в табл. 1. Operacje na typach pierwotnych w Javie - 2 Круглые скобки повышают старшинство операций, которые находятся внутри них. Так, если в приведенное выше выражение вставить скобки:
y = (x +z)*5;
то сначала будет выполнена операция сложения, а затем операция умножения. Иногда скобки используют просто для того, чтобы сделать выражение более читаемым, например:
(x > 1) && (x <= 5);

Преобразование и приведение типов при выполнении операций

В операции присваивания и арифметических выражениях могут использоваться литералы, переменные и выражения разных типов, например:
double y;
byte x;
y = x + 5;
В этом примере выполняется операция сложения переменной x типа byte и литерала 5 (типа int) и результат присваивается переменной y типа double. В Java, Jak и в языке C, преобразования типов при вычислении выражений могут выполняться автоматически, либо с помощью оператора приведения типа. Однако правила приведения типов несколько отличаются от правил языка C, и в целом являются более строгими, чем в языке C. При выполнении операции присваивания преобразование типов происходит автоматически, если происходит расширяющее преобразование (widening conversion) и два типа совместимы. Расширяющими преобразованиями являются преобразования byte® short® int® long® float® double. Для расширяющих преобразований числовые типы, включая целый и с пла­вающей точкой, являются совместимыми друг с другом. Однако числовые типы не совместимы с типами char и boolean. Типы char и boolean не совмес­тимы также и друг с другом. В языке Java выполняется автоматическое преобразование типов также и при сохранении литеральной целочисленной константы (которая имеет по умолчанию тип int) в перемен­ных типа byte, short Lub long (однако если литерал имеет oznaczający вне диапазона допустимых значений для данного типа, выдается сообщение об ошибке: возможная потеря точности). Если преобразование является сужающим (narrowing conversion), т. е. выполняется преобразование byte¬ short¬ char¬ int¬ long¬ float¬ double, то такое преобразование может привести к потере точности числа Lub к его искажению. Поэтому при сужающих преобразованиях при компиляции программы выводится диагностическое сообщение о несовместимости типов и файлы классов не создаются. Такое сообщение будет выдано и при попытке преобразование выражений типа byte Lub short в переменную типа char. Если все же необходимо выполнить такие преобразования, используется операция приведения (cast) типа, которая имеет следующий формат: ( тип-преобразования) oznaczający, где тип-преобразования определяет тип, в который необходимо преобразовать заданное oznaczający, например, в результате выполнения операторов:
byte x = 71;
char symbol = (char) x;
переменная symbol получит oznaczający ' G'. Если oznaczający с плавающей точкой присваивается целому типу, то (если oznaczający с плавающей точкой имеет дробную часть) при явном преобразовании типа происходит также усечение (truncation) числа. Так, в результате выполнения оператора
int x = (int) 77.85;
переменная x получит oznaczający 77. Если же присваиваемое oznaczający лежит вне диапазона типа-преобразования, то результатом преобразования будет остаток от деления значения на модуль диапазона присваиваемого типа (для чисел типа byte модуль диапазона будет równa się 256, для short – 65536, для int – 4294967296 и для long – 18446744073709551616). Например, в результате выполнения оператора
byte x = (byte) 514;
переменная x получит oznaczający 2. При преобразовании целых Lub вещественных чисел в данные типа char, преобразование в символ происходит, если исходное число лежит в диапазоне от 0 до 127, иначе символ получает oznaczający ' ?'. При выполнении арифметических и побитовых преобразований все значения byte и short, а также char расширяются до int, (при этом в вычислениях для char используется числовое oznaczający kodа символа) затем, если хотя бы один операнд имеет тип 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;
перед выполнением сложения oznaczający переменных x и y будет расширено до int, а затем при выполнении попытки присвоения результата вычисления типа int переменной типа byte будет выдано сообщение об ошибке. Coбы этого избежать надо использовать во втором операторе явное преобразование типов:
x = (byte) (x + y);
Выражение x + y необходимо заключит в скобки потому, что приоритет операции приведения типа, заключенной в скобки, выше, чем приоритет операции сложения. Кстати, если записать второй оператор в виде:
x += y;
то wiadomości об ошибке не будет. Ссылка на первоисточник: Операции над примитивными типами в Java
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION