Примитивные типы данных в Java

1. Введение

Java как язык программирования является одновременно статически-типизированными и строго-типизированным.

Статическая типизация означает, что тип данных каждой переменной и каждого выражения должен быть объявлен до момента их использования.

Строгая типизация выражается тем, что каждый примитивный тип данных обладает определенным лимитом значения, который переменная может хранить или выражение может произвести.

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

2. Пререквизиты

2.1 Signed и Unsigned

Unsigned - двоичные числа не содержащие знаков и хранящие большие значения. Диапазон допустимых значений начинается с нуля и продвигается в сторону положительных чисел.

Signed - двоичные числа, которые могут содержать знаки и соответственно могут хранить положительные и отрицательные числа. Разграничение положительного и отрицательного числа достигается наличием дополнительного бита.

0 означает положительное число, а 1 - отрицательное.

2.2 Дополнительный код

Дополнительный код является наиболее распространенным способом представления отрицательных целых чисел в компьютерах и его часто называют two’s complement.

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

При записи числа в дополнительном коде старший разряд является знаковым. Если его значение равно 0, то в остальных разрядах записано положительное двоичное число, совпадающее с прямым кодом.

Двоичное 8-разрядное число (8 бит) со знаком в дополнительном коде может представлять любое целое в диапазоне от −128 до +127. Если старший разряд равен нулю, то наибольшее целое число, которое может быть записано в оставшихся 7 разрядах, равно 2^7-1=127.

3. Виды

3.1 Целочисленные

byte - это signed 8-bit two’s complement целое число. Его минимально возможное значение -128 до максимально возможного 127 (включительно).

byte a = 26; // десятичная форма представления
byte b = 0x1a; // шестнадцатеричная форма представления
byte c = 0b11010; // двоичная форма представления

short - это signed 16-bit two’s complement целое число. Его минимально возможное значение -32,768 до максимально возможного 32,767 (включительно).

short a = 26; // десятичная форма представления
short b = 0x1a; // шестнадцатеричная форма представления
short c = 0b11010; // двоичная форма представления

int - это signed 32-bit two’s complement целое число (по-умолчанию). Его минимально возможное значение -2^31 до максимально возможного 2^31-1 (включительно). В Java 8 и версиях позднее появилась возможность использовать int как unsigned, где минимально возможное число будет 0, а максимально возможное 2^32-1.

int a = 26; // десятичная форма представления
int b = 0x1a; // шестнадцатеричная форма представления
int c = 0b11010; // двоичная форма представления

long - это signed 64-bit two’s complement целое число. Его минимально возможное значение -2^63 до максимально возможного 2^63-1 (включительно). В Java 8 и версиях позднее появилась возможность использовать int как unsigned, где минимально возможное число будет 0, а максимально возможное -2^64-1.

long a = 26; // десятичная форма представления
long b = 0x1a; // шестнадцатеричная форма представления
long c = 0b11010; // двоичная форма представления

Важно знать, что число 2147483649 является допустимым для типа long, но выходит за предельные значения для типа int.

По-умолчанию все целочисленные значения определяются как тип int и при попытке компиляции произойдет ошибка, если переменной типа long присвоить число указанное выше.

Чтобы избежать этой проблемы, необходимо добавить к числовому значению суффикс l или L. Это явно укажет компилятору, что данное число расценивается как тип long.

long a = 2147483649l;
long b = 2147483649L;

char - это символ значение которого представлено в виде unsigned 16-bit целого числа в кодировке UTF-16. Его минимально возможное значение '\u0000' (или 0) до максимально возможного \uffff' (or 65,535 включительно).

char qChar1 = 'q'; // явно указанный символ 
char qChar2 = 71; // шестнадцатеричная форма представления
char aChar3 = '\u0071'; // Unicode (UTF-16) представление

3.2 Числа с плавающей запятой

float - это 32-битное число с плавающей точкой одинарной точности стандарта IEEE 754. Диапазон допустимых значений от ~1,4*10^-45 до ~3,4*10^38

float a = 26; // десятичная форма представления
float b = 0x1a; // шестнадцатеричная форма представления
float c = 0b11010; // двоичная форма представления
float d = 1.2f;
float e = 22.06F;

Java автоматически распознает любое дробное значение как значение типа double. Как и в случае с long, необходимо явно указывать суффикс f или F для распознавания значения как тип данных float.

double - это 64-битное число с плавающей запятой двойной точности стандарта IEEE 754. Диапазон допустимых значений от ~4,9*10^-324 до ~1,8*10^308

double a = 26; // десятичная форма представления
double b = 0x1a; // шестнадцатеричная форма представления
double c = 0b11010; // двоичная форма представления
double d = 1.2;
double e = 10d; // суффикс опциональный
double f = 22.06D; // суффикс опциональный

3.3 Логический

boolean - логически типа данных, который представлен двумя возможными значениями true или false, иначе говоря истина или ложь. Данный тип хранит 1 бит информации, но его реальных размер зависит от Java SE Specifications.

boolean isTrue = true; // истина 
boolean isFalse = false; // ложь

4. Литералы

Мы уже знаем, что примитивные типы данных являются предопределенными и уже встроены в язык программирования Java.

Это позволяет делать записи с применением фиксированных значений и на месте присваивать их переменным.

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

boolean isTrue = true;
char capitalC = 'C';
byte b = 101;
int i = 101010;
double d = 123.4;

Источник