Ссылочные типы данных — Java: Введение в ООП
Классы в Java особым образом связаны с типами данных. Посмотрите на пример:
var user = new User("Danil", "Miloshin"); Каким будет реальный тип в данном случае? Классы, сами по себе, ведут себя как типы. Поэтому типом переменной user будет User , то есть так:
User user = new User("Danil", "Miloshin"); В Java все типы данных делятся на две категории: примитивные и ссылочные. К примитивным относятся все виды чисел, символы и логический тип данных (булеан). К ссылочным — классы, массивы, строки. В зависимости от категории, значительно меняется поведение кода и об этом нужно знать. В этом уроке мы разберем отличия между этими категориями и научимся правильно с ними работать.
Для изучения нам понадобится пример какого-то класса, чьи объекты мы используем в примерах кода. Возьмем для простоты класс User с двумя полями и одним конструктором:
class User public String firstName; public String lastName; public User(String firstName, String lastName) this.firstName = firstName; this.lastName = lastName; > > Значение по умолчанию
Примитивные данные всегда имеют значение, даже если они определяются без инициализации:
int a; System.out.println(a); // => 0 У ссылочных в качестве значения по умолчанию используется null . Это специальное значение, которое может быть использовано в качестве любого объекта
User u; System.out.println(u); // => null // Можно присваивать и явно // User u = null; Присваивание
Примитивное значение всегда копируется при присваивании:
// Содержимое a и b не связаны var a = 5; var b = a; Ссылочные же данные не копируются. При присваивании переменные начинают указывать (ссылаться) на один и тот же объект:
var u1 = new User("Igor", "Mon"); // Обе переменные ссылаются на один тот же объект var u2 = u1; u2.firstName = "Nina"; System.out.println(u1.firstName); // => Nina u1 == u2; // true // u2 теперь ссылается на другой объект // Содержимое объекта при этом не важно, оно может быть одинаковым, а может быть разным // Java проверяет только то, та же ли это ссылка или нет u2 = new User("Igor", "Mon"); u1 == u2; // false Больше всего это проявляется при передаче данных в методы и их возврате оттуда. Ссылочное значение передается по ссылке, а значит его можно изменить изнутри метода.
class UserController // Ничего не нужно возвращать, потому что пользователь будет изменен напрямую public static void replaceName(User user, String newFirstName) user.firstName = newFirstName; > > var u = new User("Igor", "Mon"); UserController.replaceName(u, "Nina"); System.out.println(u.firstName); // => "Nina" Сравнение
Примитивные данные сравниваются по значению. Пять всегда равно пяти, истина всегда равна истине:
var a = 5; var b = 5; a == b; // true var t1 = true; var t2 = true; t1 == t2; // true Ссылочные сравниваются по ссылкам, а не на основе содержимого. Объекты равны только сами себе. То что хранится внутри них — не важно.
var u1 = new User("Igor", "Mon"); var u2 = new User("Igor", "Mon"); // Проверяется только ссылка, указывает она на тот же объект или нет u1 == u2; // false // Объект равен сам себе, что ожидаемо u1 == u1; // true u2 == u2; // true Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях:
Примитивные типы данных
Типы в Java распределены на две категории: примитивные (простые) и ссылочные (объектные). Ссылочные типы — это массивы, классы и интерфейсы.
В этом разделе мы рассмотрим примитивные типы. Примитивы в Java предопределены заранее и поименованы зарезервированными словами (keywords).
Примитивные типы можно разделить на следующие четыре группы:
- Целые числа. Эта группа включает в себя типы данных byte , short , int и long , представляющие целые числа со знаком.
- Числа с плавающей точкой. Эта группа включает в себя типы данных flоаt и double , представляющие числа с точностью до определенного знака после десятичной точки.
- Символы. Эта группа включает в себя тип данных char , представляющий символы, например буквы и цифры, из определенного набора.
- Логические значения. Эта группа включает в себя тип данных boolean , специально предназначенный для представления логических значений.
Следующая таблица содержит информацию о длине, диапазоне допустимых значений и значения по умолчанию примитивных типов:
| Тип | Размер в байтах | Размер в битах | Возможные значения (от..до) | Значение по умолчанию |
|---|---|---|---|---|
| boolean | — | 1 | true или false | false |
| byte | 1 | 8 | -128..127 | 0 |
| short | 2 | 16 | -32,768..32,767 | 0 |
| int | 4 | 32 | -2,147,483,648..2,147,483,647 | 0 |
| long | 8 | 64 | -9,223,372,036,854,775,808..9,223,372,036,854,775,807 | 0 |
| char | 2 | 16 | 0..65,535 | ‘\u0000’ |
| float | 4 | 32 | -3.4E+38..3.4E+38 (стандарт IEEE 754) | 0.0 |
| double | 8 | 64 | -1.7E+308..1.7E+308 (стандарт IEEE 754) | 0.0 |
Презентацию с видео можно скачать на Patreon .
Примитивные типы Java
В Java есть восемь примитивных типов данных, но в моделях AnyLogic обычно используются следующие четыре:
| Имя типа | Представляет | Примеры констант |
|---|---|---|
| int | Целые числа | 12 10000 -15 0 |
| double | Вещественные числа | 877.13 12.0 12. 0.153 .153 -11.7 3.6e-5 |
| boolean | Логические значения | true false |
| String | Текстовые строки | «AnyLogic» «X = » «Line\nNew line» «» |
Слово double означает вещественное число с двойной точностью. В исполняющем модуле AnyLogic все вещественные значения (такие, как время, координаты, длина, скорость, случайные числа) имеют двойную точность.
Тип String на самом деле является классом, а не примитивным типом (обратите внимание, что его имя начинается с заглавной буквы), но это основополагающий класс, поэтому некоторые операции работы со строками встроены в ядро языка Java.
Обратите внимание на численные константы. В зависимости от способа написания числа, Java может трактовать его либо как целое, либо как вещественное. Любое число с разделителем целой части от дробной . считается вещественным числом, даже если дробная часть опущена или содержит только нули (это существенно для операции целочисленного деления). Если целая или вещественная часть числа равна нулю, то она может быть опущена, поэтому .153 — тоже, что и 0.153 , а 12. равно 12.0 .
Логические константы в Java — true и false и в отличие от языков C или C++, они не могут преобразовываться в численные аналоги и обратно, поэтому нельзя работать со значением false как с 0, а с ненулевым числом как с true .
Строковые константы представляют собой последовательность символов, заключенных в символы кавычек. Пустая строка (строка, не содержащая символов) обозначается как «» . Специальные символы добавляются в строковые константы с помощью управляющих последовательностей символов, начинающихся с обратной косой черты. Например, конец строки обозначается последовательностью символов \n , поэтому строка «First line\nSecond line» будет отображаться как:
First line Second lineЕсли вы хотите включить в строку кавычки, то вам будет нужно написать \» , например, строковая константа «Строка с \» посередине» при выводе на печать примет вид:
Строка с " посерединеЧтобы добавить в строку обратную черту, поместите двойной символ обратной черты:
Java/Типы данных
В Java есть 8 примитивных типов, которые делят на 4 группы, вот они:
- Целые числа — byte, short, int, long
- Числа с плавающей точкой (иначе вещественные) — float, double
- Логический — boolean
- Символьный — char
Целочисленные типы [ править ]
Целочисленные типы различаются между собой только диапазонами возможных значений, например, для хранения номера элемента в таблице Менделеева пока хватит переменной типа byte.
| Тип | Размер (бит) | Диапазон |
|---|---|---|
| byte | 8 бит | от -128 до 127 |
| short | 16 бит | от -32768 до 32767 |
| char | 16 бит | беззнаковое целое число, представляющее собой символ UTF-16 (буквы и цифры) |
| int | 32 бит | от -2147483648 до 2147483647 |
| long | 64 бит | от -9223372036854775808L до 9223372036854775807L |
Пример использования целочисленных типов:
public class IntegralTypes public static void main(String[] args) byte b = 216; // Вот тут будет ошибка, т.к. у нас диапазон от -128 до 127! short s = 1123; int i = 64536; long l = 2147483648L; // Постфикс l или L обозначает литералы типа long System.out.println(i); System.out.println(b); System.out.println(s); System.out.println(l); > >
Символы тоже относят к целочисленным типам из-за особенностей представления в памяти и традиций.
public class Characters public static void main(String[] args) char a = 'a', b, c = 'c'; b = (char) ((a + c) / 2); // Можно складывать, вычитать, делить и умножать // Но из-за особенностей арифметики Java результат приходится приводить к типу char явно System.out.println(b); // Выведет символ 'b' > >
Типы с плавающей точкой [ править ]
| Тип | Размер (бит) | Диапазон |
|---|---|---|
| float | 32 | от 1.4e-45f до 3.4e+38f |
| double | 64 | от 4.9e-324 до 1.7e+308 |
public class FloatingPointTypes public static void main(String[] args) double a, b = 4.12; a = 22.1 + b; float pi = 3.14f; // При использовании типа float требуется указывать суффикс f или F // так как без них типом литерала будет считаться double float anotherPi = (float) 3.14; // Можно привести явно double c = 27; double d = pi * c; System.out.println(d); > >
Логический тип [ править ]
| Тип | Размер (бит) | Значение |
|---|---|---|
| boolean | 8 (в массивах), 32 (не в массивах используется int) | true (истина) или false (ложь) |
В стандартной реализации Sun JVM и Oracle HotSpot JVM тип boolean занимает 4 байта (32 бита), как и тип int. Однако, в определенных версиях JVM имеются реализации, где в массиве boolean каждое значение занимает по 1-му байту.
Ссылочные [ править ]
Ссылочные типы — это все остальные типы: классы, перечисления и интерфейсы, например, объявленные в стандартной библиотеке Java, а также массивы.
Строки [ править ]
Строки это объекты класса String, они очень распространены, поэтому в некоторых случаях обрабатываются отлично от всех остальных объектов. Строковые литералы записываются в двойных кавычках.
public class Strings public static void main(String[] args) String a = "Hello", b = "World"; System.out.println(a + " " + b); // Здесь + означает объединение (конкатенацию) строк // Пробел не вставляется автоматически // Строки конкатенируются слева направо, надо помнить это когда соединяешь строку и примитив String c = 2 + 2 + ""; // "4" String d = "" + 2 + 2; // "22" d = "" + (2 + 2); // а теперь d тоже "4" String foo = "a string"; String bar = "a string"; // bar будет указывать на тот же объект что и foo String baz = new String("a string"); // Чтобы гарантированно создать новую строку надо вызвать конструктор System.out.println("foo == bar ? " + (foo == bar)); // == сравнивает ссылки на объекты System.out.println("foo равен bar ? " + (foo.equals(bar))); // Метод equals служит для проверки двух объектов на равенство System.out.println("foo == baz ? " + (foo == baz)); System.out.println("foo равен baz ? " + (foo.equals(baz))); > >
Эта программа выведет:
Hello World
foo == bar ? true
foo равен bar ? true
foo == baz ? false
foo равен baz ? true
Обертки [ править ]
Если требуется создать ссылку на один из примитивных типов данных, необходимо использовать соответствующий класс-обертку. Также в таких классах есть некоторые полезные методы и константы, например минимальное значение типа int можно узнать использовав константу Integer.MIN_VALUE. Оборачивание примитива в объект называется упаковкой (boxing), а обратный процесс распаковкой (unboxing).
| Тип | Класс-обертка |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
| boolean | Boolean |
int i; Integer boxed; // Обычное создание объекта boxed = new Integer(i); // Фабричный метод boxed = Integer.valueOf(i); // Автоматическая упаковка, компилятор просто вставит вызов Integer.valueOf boxed = i;
Рекомендуется использовать valueOf, он может быть быстрее и использовать меньше памяти потому что применяет кэширование, а конструктор всегда создает новый объект.
Получить примитив из объекта-обертки можно методом Value.
Integer boxed; int i; // Явная распаковка i = boxed.intValue(); // Автоматическая распаковка i = boxed;