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

1. Введение
2. Целочисленные типы
   • Десятичные литералы
   • Восьмеричные литералы
   • Шестнадцатеричные литералы
   • Двоичные литералы
   • Подчеркивание в числовых литералах
3. float и double типы
4. boolean тип
5. char тип
6. Строковые литералы

1. Введение

В этой статье мы рассмотрим с вами примитивные типы и литералы в Java. Типы в Java делятся на две категории: примитивные (простые, базовые) и ссылочные (объектные). Ссылочные типы - это массивы, классы и интерфейсы. 

В этом разделе мы рассмотрим только примитивные типы.

Примитивы в Java предопределены заранее и поименованы ключевыми словами (keywords).

Примитивные типы можно разделить на следующие четыре группы:

1. Целые числа. Эта группа включает в себя типы данных byte, short, int и long, представляющие целые числа со знаком.

2. Числа с плавающей точкой. Эта группа включает в себя типы данных flоаt и double, представляющие числа с точностью до определенного знака после десятичной точки.

3. Символы. Эта группа включает в себя тип данных char, представляющий символы, например буквы и цифры, из определенного набора.

4. Логические значения. Эта группа включает в себя тип данных boolean, специально предназначенный для представления логических значений.

Следующая таблица содержит информацию о длине, диапазоне допустимых значений и значения по умолчанию примитивных типов:

Давайте начнём с целочисленных типов. Целочисленные числа представлены в языке Java четырьмя типами - byte, short, int и long. Первый вопрос, который все конечно же задают - зачем так много? Целочисленные типы различаются размером в байтах и конечно же возможными значениями. В зависимости от того, какие данные будут хранить ваш тип, вы выбираете одно из этих значений. 

byte — используется для передачи данных по сети, записи и чтения из файла. В математических операциях, как правило, не используется.

short — самый редко используемый тип в Java, может использоваться только в целях экономии памяти.

int — основной целочисленный тип, используемый в Java по умолчанию. Поэтому если вы не знаете какой тип вам выбрать, выбирайте смело int значение. Любое целое число будет рассматриваться компилятором как число типа int. Используется в качестве счётчика циклов, индексов массивов и индексов символов в строках.

long — целочисленный тип содержащий практически бесконечное количество значений. Используется в случаях, где числа превосходят 2 миллиарда и стандартного int уже не хватает. Используется в повседневной жизни для создания уникальных значений.

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

Давайте посмотрим на пример объявления и инициализации целочисленных примитивных типов:

byte b = 4;
short s1 = 7, s2 = 5;
int i1 = 56, i2;
i2 = 78;
long a1 = 456;

Значение, которое указывается после равно, называется литерал. В некоторых источниках также называют её константой, но я буду придерживаться термина литерал.

Целочисленные литералы бывают нескольких видов:

• десятичные 
• восьмеричные 
• шестнадцатеричные  
• двоичные - начиная с Java 7

Что это такое? Смотрите - существуют разные системы исчисления. 

2.1 Десятичные литералы

То есть, та система исчисления к которой мы привыкли - это десятичная. В ней мы используем 10 цифр для обозначения какого-то числа - от 0 до 9.

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

int x1 = 878;
int x2 = +878;
int x3 = -878;

2.2. Восьмеричные литералы

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

int six = 06; // Равно десятичному числу 6
int seven = 07; // Равно десятичному числу 7
int eight = 010; // Равно десятичному числу 8
int nine = 011; // Равно десятичному числу 9

System.out.println("eight: " + eight);
System.out.println("nine: " + nine);

Когда мы выводим на консоль такие значения, то они выводятся всегда в десятичном формате:

eight: 8
nine: 9

2.3. Шестнадцатеричные литералы

• Шестнадцатеричные литералы создаются используя следующие символы [0-9a-fA-F]
• Должны начинаться с 0x или 0X.
• Разрешается использовать до 16 символов в шестнадцатеричных числах, не учитывая префикс 0x и необязательный суффикс L.

Например:

int a1 = 0X0005;
int a2 = 0x7ddfffff;
int a3 = 0xcccccccc;

2.4. Двоичные литералы в Java 7

Для определения двоичного литерала, добавьте префикс 0b или 0B к числу. Используются числа 0 и 1. Например:

int i1 = 0b101;
int i2 = 0B101; 

Все целочисленные литералы представляют значения int. Если значение литерала лежит в диапазоне byte, short или char, то его можно присвоить переменной этого типа без приведения типов.

Для создания литерала типа long, необходимо явно указать компилятору, дополнив литерал буквой 'l' или 'L'. Но всё-таки лучше использовать большую L, потому что маленькая l очень похожа на единичку:

long a1 = 220433L;
long a2 = 0x3FFl;

Когда это может быть необходимо? Допустим, у вас есть какое-то большое число, которое не входит в диапазон int.

2.5. Подчеркивание в числовых литералах

Начиная с Java 7, добавлена возможность использовать любое количество символов подчеркивания для разделения групп цифр, что улучшает читабельность.

Подчеркивание может разделять только цифры! Нельзя использовать подчеркивания в следующих местах:

• В начале или конце числа
• Рядом с десятичной точкой в числе с плавающей точкой
• Перед 'F', 'f', 'l' или 'L' суффиксами
• Для разделения символов префиксов

int i1 = 12_567;            // OK
double d1 = 56.356_234;      // OK
short s = 0b000____0100;    // OK
int i2 = 220_;              // Ошибка компиляции
int i3 = 0_x2F;             // Ошибка компиляции
int i4 = 0x_3E;             // Ошибка компиляции
float f1 = 6345.56_f;       // Ошибка компиляции
float f2 = 3423_.87f;       // Ошибка компиляции

3. float и double типы

Числа с плавающей точкой (или действительные числа) представлены типами float и double. Используются для хранения значений с точностью до определенного знака после десятичной точки:

double — это числа с двойной точностью, максимально приближённые к заданным или полученным в результате вычислений значениям. Используется в Java для любых математических вычислений (квадратный корень, синус, косинус).

float — менее точный тип с плавающей точкой. Используется реже с целью экономии памяти.

Давайте посмотрим на пример объявления примитивных типов с плавающей точкой. Всем литералам с плавающей точкой по умолчанию присваивается тип double. Для отделения дробной части используется точка, не запятая. Если целое число у вас ноль, то этот нолик можно опустить, можно просто написать .4:

double d1 = 145454545.676767676;
double d2 = .4;// число 0.4

Если вы хотите создать литерал типа float, нужно после литерала указать буковку F большую либо маленькую. В следующем примере создаются три переменные f1, f2, f3:

float f1 = 56.45455; // Ошибка компиляции
float f2 = 343434.454563F; 
float f3 = 78.45f;

Для переменной f1 не указана в конце F, а значит литерал имеет значение типа double. Поэтому в этой строке произойдёт ошибка компиляции. f2 и f3 указаны верно - в конце мы ставим в качестве префикса букву F.

Также для того, чтобы явно указать что наш литерал имеет значение double, мы можем в конце добавить символ D большой или маленький, но это не обязательно. Допустим, как это сделано в следующем примере для переменных d3 и d5:

double d3 = 454545.454545D; 
double d4 = 654.321; 
double d5 = 54.32d;

double d6 = 1.5e14;   //Значение этого числа равно 1.5*10^14
double d7 = 1.5E+14; //Значение этого числа равно 1.5*10^14 
double d8 = 1.5e-14;  //Значение этого числа равно 1.5*10^-14

В языке Java есть три специальных числа плавающей точкой, которые используются для обозначения переполнения и ошибок:

• Положительная бесконечность - результат деления положительного числа на 0. Представлены константами Double.POSITIVE_INFINITY и Float.POSITIVE_INFINITY.
• Отрицательная бесконечность - результат деления отрицательного числа на 0. Представлены константами Double.NEGATIVE_INFINITY  и Float.NEGATIVE_INFINITY.
• NaN (не число) - вычисление 0/0 или извлечение квадратного корня из отрицательного числа. Представлены константами Double.NaN и Float.NAN.

Пример использования специальных чисел с плавающей точкой в арифметических выражениях:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        double b = 0.0;
        double c = -0.0;
        double g = Double.NEGATIVE_INFINITY;

        System.out.println(a / b);
        System.out.println(a / c);
        System.out.println(b == c);
        System.out.println(g * 0);
    }
}

Числа с плавающей точкой нельзя использовать в финансовых расчетах, где ошибки округления недопустимы. Например, в результате выполнения оператора System.out. println(2.0 - 1.1) будет выведено значение 0.8999999999999999, а не 0.9, как было бы логично предположить. Подобные ошибки связаны с внутренним двоичным представлением чисел. Как в десятичной системе счисления нельзя точно представить результат деления 1/3, так и в двоичной системе невозможно точно представить результат деления 1/10. Если же требуется исключить ошибки округления, то следует воспользоваться классом BigDecimal.

4. boolean тип

boolean b1 = false;
boolean b2 = true;

Следующий пример инициализации логической переменной является неправильным. В некоторых языках программирования для логических литералов используется ноль и единица. В Java так сделать нельзя - это не откомпилируется:

boolean b3 = 0; 

5. char тип

char c1 = 'n'; 
char c2 = '#';

Также мы можем задавать символьные литералы, используя значение Unicode, так как тип char в Java поддерживает значение Unicode. В этом случае мы используем не его символ, а числовое значение этого символа. Именно поэтому тип char еще называют псевдоцелочисленным типом. Но эти значения могут быть только положительные. И как мы увидим в следующих уроках, мы даже можем применять арифметические операции к типу char. 

Для каждого символа в таблице Unicode, которая содержит все буквы, числа и специальные символы, существует свой код. С помощью этого типа мы можем представить какой-то один символ. В Java мы можем задать этот код с помощью любой системы исчисления.  Но если мы посмотрим на табличку Unicode, то мы увидим что там значения заданы в шестнадцатеричном формате:

char letterO = '\u004F'; // Буква 'O' в шестнадцатеричной форме
char letterA = '\141';  // Буква 'a' в восьмеричной форме
char a1 = 0x675; // шестнадцатеричный целочисленный литерал 
char a2 = 345; // десятеричный целочисленный литерал 	

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

Например, при выполнении этого кода

char c2 = 97;
System.out.println(c2);

на консоль выведется 

a

Для определения некоторых символьных литералов используется обратная косая черта. Допустим, если мы хотим задать значение кавычка, то мы должны эту кавычку экранировать с помощью обратной косой черты:

char c1 = '\''; 

Если мы хотим задать символ перевода строки, это делается таким образом:

char c2 = '\n';

И третий вариант, где мы можем использовать обратную косую черту - это табуляция:

char c3 = '\t';

6. Строковые литералы

Также в этом уроке мы рассмотрим с вами строковые литералы, хотя, конечно же, строки не являются примитивными типами.

• Для обозначения строковых литералов последовательность символов заключается в двойные кавычки, в отличие от символьных литералов, для обозначения которых используются одинарные кавычки.
• Управляющие символы и восьмеричная или шестнадцатеричная форма записи, определенные для символьных литералов, действуют точно так же и в строковых литералах.

String str1 = "MyProgram";
String str2 = "first line\nsecond line";
String str3 = "\"This is in quotes\"";
String str4 = "\u004F letter";//O letter

Презентацию с видео можно скачать на Patreon.