Java 7 - [14]

int i = -100, j = 100, k = 9999;

long big = 50, veryBig = 2147483648L;

char c1 = 'A', c2 = '?', c3 = 36, newLine = '\n';

Целые типы, кроме char, хранятся в двоичном виде с дополнительным кодом. Последнее означает, что для отрицательных чисел хранится не их двоичное представление, а дополнительный код этого двоичного представления.

Дополнительный код получается так: в двоичном представлении числа все нули меняются на единицы, а единицы на нули, после чего к результату прибавляется единица, разумеется, в двоичной арифметике.

Например, значение 50 переменной b1, определенной ранее, будет храниться в одном байте с содержимым 00110010, а значение -99 переменной b2 — в байте с содержимым, которое вычисляется так: число 99 переводится в двоичную форму, получая 01100011, меняются единицы и нули, получая 10011100, и прибавляется единица, получая окончательно байт с содержимым 10011101.

Смысл всех этих преобразований в том, что сложение числа с его дополнительным кодом в двоичной арифметике даст в результате нуль; старший бит, равный 1, просто теряется, поскольку выходит за разрядную сетку. Это означает, что в такой странной арифметике дополнительный код числа является противоположным к нему числом, числом с обратным знаком. А это, в свою очередь, означает, что вместо того, чтобы вычесть из числа A число B, можно к A прибавить дополнительный код числа B. Таким образом, операция вычитания исключается из набора машинных операций.

Над целыми типами можно производить массу операций. Их набор восходит к языку С, он оказался удобным и кочует из языка в язык почти без изменений. Особенности применения этих операций в языке Java показаны на примерах.

Операции над целыми типами

Все операции, которые производятся над целыми числами, можно разделить на следующие группы.

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

К арифметическим операциям относятся:

□ сложение — + (плюс);

□ вычитание — - (дефис);

□ умножение — * (звездочка);

□ деление — / (наклонная черта, слэш);

□ взятие остатка от деления (деление по модулю) — % (процент);

□ инкремент (увеличение на единицу) — ++;

□ декремент (уменьшение на единицу)---.

Между сдвоенными плюсами и минусами нельзя оставлять пробелы.

Сложение, вычитание и умножение целых значений выполняются как обычно, а вот деление целых значений в результате дает опять целое (так называемое целочисленное деление), например 5/2 даст в результате 2, а не 2,5, а 5/(-3) даст -1. Дробная часть попросту отбрасывается, происходит так называемое усечение частного. Это поначалу обескураживает, но потом оказывается удобным для усечения вещественных чисел.

Замечание

В Java принято целочисленное деление.

Это странное для математики правило естественно для программирования: если оба операнда имеют один и тот же тип, то и результат имеет тот же тип. Достаточно написать 5/2.0 или 5.0/2 или 5.0/2.0, и получим 2,5 как результат деления вещественных чисел.

Операция деление по модулю определяется так:

a % b = a — (a / b) * b

например, 5%2 даст в результате 1, а 5%(-3) даст 2, т. к. 5 = (-3) * (-1) + 2, но (-5)%3 даст -2, поскольку -5 = 3 * (-1) — 2.

Операции инкремент и декремент означают увеличение или уменьшение значения переменной на единицу и применяются только к переменным, но не к константам или выражениям, нельзя написать 5++ или (a + b)++.

Например, после приведенных ранее описаний i++ даст -99, а j -- даст 99.

Интересно, что эти операции можно записать и перед переменной: ++i, --j. Разница проявится только в выражениях: при первой форме записи (постфиксной) в выражении участвует старое значение переменной и только потом происходит увеличение или уменьшение ее значения. При второй форме записи (префиксной) сначала изменится переменная, и ее новое значение будет участвовать в выражении.

Например, после приведенных ранее описаний (k++) + 5 даст в результате 10004, а переменная k примет значение 10000. Но в той же исходной ситуации (++k) + 5 даст 10005, а переменная k станет равной 10000.

Приведение типов

Результат арифметической операции имеет тип int, кроме того случая, когда один из операндов типа long. В этом случае результат будет типа long.

Перед выполнением арифметической операции всегда происходит повышение (promotion) типов byte, short, char. Они преобразуются в тип int, а может быть, и в тип long, если другой операнд типа long. Операнд типа int повышается до типа long, если другой операнд типа long. Конечно, числовое значение операнда при этом не меняется.

Это правило приводит иногда к неожиданным результатам. Попытка скомпилировать простую программу, представленную в листинге 1.3, приведет к сообщениям компилятора, показанным на рис. 1.3.

Листинг 1.3. Неверное определение переменной

class InvalidDef{

public static void main(String[] args){

byte b1 = 50, b2 = -99;

short k = b1 + b2; // Неверно!

System.out.println(„k=" + k);

}

}

Рис. 1.3. Сообщения компилятора об ошибке

Эти сообщения означают, что в файле InvalidDefjava, в строке 4, обнаружена возможная потеря точности (possible loss of precision). Затем приводятся обнаруженный (found) и нужный (required) типы, выводится строка, в которой обнаружена (а не сделана) ошибка, и отмечается символ, при разборе которого найдена ошибка. Затем указано общее количество обнаруженных (а не сделанных) ошибок (1 error).