Что хранится в переменной не примитивного типа
Перейти к содержимому

Что хранится в переменной не примитивного типа

  • автор:

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

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

Что же такое переменная

Для того, чтобы тебе было проще понять, что такое переменная, вернемся к школьному курсу и вспомним простую формулу:

Если мы подставим значение к «х», например, х = 1, то значение выражения будет равно «2». Соответственно, если х = 2, значение выражения будет «3» и так далее. Как видишь, все достаточно просто. «Х» в нашем случае переменная, куда мы помещаем любое значение. Подставляя его в формулу, мы получаем определенный результат.

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

Какие типы переменных бывают в Java

В этом языке программирования выделяют четыре типа переменных:

  1. Целочисленные. К этому типу относятся такие переменные, как byte, short, int, long.
  2. С плавающей точкой. Сюда относятся float и double.
  3. Символы.
  4. Логические.

Как видно, всего переменных 8, однако есть еще и девятый тип переменных – void. Но этот тип мы не будем рассматривать в данной статье. Познакомимся поближе с каждым из типов переменных.

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

Уже из названия понятно, что в качестве значения таким переменным присваиваются целые числа. Например, это может быть 5, 10, 25, 100 и так далее. Причем они могут быть как положительными, так и отрицательными, в зависимости от потребности разработчика. А теперь рассмотрим подробнее каждый из видов переменных:

  1. Byte – принимает значение от -128 до 127. Размер этой переменной – 1 байт памяти, что вполне логично исходя из названия.
  2. Short – может принимать значения от -32768 до 32767. Размер такой переменной 2 байта.
  3. Int – эта целочисленная переменная может принимать значения от -2147483648 до 2147483647. Ее размер составляет 4 байта.
  4. Long – это самая большая с точки зрения размера переменная (8 байтов памяти). Она может принимать значения от -9223372036854775808 до 9223372036854775807.

В принципе, несложно понять, когда и в какой ситуации использовать каждую из этих переменных. Но для закрепления приведем маленький пример. Предположим, у Васи 5 апельсинов, а у Кати и Ани по 3. Нужно определить сколько всего апельсинов у ребят. Нетрудно догадаться, что здесь требуется использование целочисленных переменных, так как апельсины целые и не предполагается, что их будут делить на дольки.

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

Дальше, представим, что Вася, Катя и Аня выросли и стали заниматься поставками апельсинов. Теперь у каждого больше 1000 единиц этого вкусного фрукта. Объявлять byte мы больше не сможем. Если количество апельсинов не превышает 32767, мы можем работать с short, если больше с int и так далее.

Несмотря на то, что в Java представлено 4 целочисленных переменных, чаще всего будет использоваться только int. Более того этот тип в языке считается по умолчанию. А теперь посмотрим, как в Java объявляются переменные.

Приведем несколько примеров:

Что хранится в переменной не примитивного типа

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

Итак, рассмотрим систему встроенных базовых типов данных, которая используется для создания переменных в Java. А она представлена следующими типами.

    boolean : хранит значение true или false

boolean isActive = false; boolean isAlive = true;
byte a = 3; byte b = 8;
short a = 3; short b = 8;
int a = 4; int b = 9;
long a = 5; long b = 10;
double x = 8.5; double y = 2.7;
float x = 8.5F; float y = 2.7F;

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

Целые числа

Все целочисленные литералы, например, числа 10, 4, -5, воспринимаются как значения типа int , однако мы можем присваивать целочисленные литералы другим целочисленным типам: byte , long , short . В этом случае Java автоматически осуществляет соответствующие преобразования:

byte a = 1; short b = 2; long c = 2121;

Однако если мы захотим присвоить переменной типа long очень большое число, которое выходит за пределы допустимых значений для типа int, то мы столкнемся с ошибкой во время компиляции:

long num = 2147483649;

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

long num = 2147483649L;

Как правило, значения для целочисленных переменных задаются в десятичной системе счисления, однако мы можем применять и другие системы счисления. Например:

int num111 = 0x6F; // 16-теричная система, число 111 int num8 = 010; // 8-ричная система, число 8 int num13 = 0b1101; // 2-ичная система, число 13

Для задания шестнадцатеричного значения после символов 0x указывается число в шестнадцатеричном формате. Таким же образом восьмеричное значение указывается после символа 0 , а двоичное значение — после символов 0b .

Также целые числа поддерживают разделение разрядов числа с помощью знака подчеркивания:

int x = 123_456; int y = 234_567__789; System.out.println(x); // 123456 System.out.println(y); // 234567789
Числа с плавающей точкой

При присвоении переменной типа float дробного литерала с плавающей точкой, например, 3.1, 4.5 и т.д., Java автоматически рассматривает этот литерал как значение типа double . И чтобы указать, что данное значение должно рассматриваться как float , нам надо использовать суффикс f:

float fl = 30.6f; double db = 30.6;

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

Символы и строки

В качестве значения переменная символьного типа получает одиночный символ, заключенный в одинарные кавычки: char ch=’e’; . Кроме того, переменной символьного типа также можно присвоить целочисленное значение от 0 до 65535 . В этом случае переменная опять же будет хранить символ, а целочисленное значение будет указывать на номер символа в таблице символов Unicode (UTF-16). Например:

char ch=102; // символ 'f' System.out.println(ch);

Еще одной формой задания символьных переменных является шестнадцатеричная форма: переменная получает значение в шестнадцатеричной форме, которое следует после символов «\u». Например, char ch=’\u0066′; опять же будет хранить символ ‘f’.

Символьные переменные не стоит путать со строковыми, ‘a’ не идентично «a». Строковые переменные представляют объект String , который в отличие от char или int не является примитивным типом в Java:

String hello = "Hello. "; System.out.println(hello);

Кроме собственно символов, которые представляют буквы, цифры, знаки препинания, прочие символы, есть специальные наборы символов, которые называют управляющими последовательностями. Например, самая популярная последовательность — «\n». Она выполняет перенос на следующую строку. Например:

String text = "Hello \nworld"; System.out.println(text);

Результат выполнения данного кода:

Hello world

В данном случае последовательность \n будет сигналом, что необходимо сделать перевод на следующую строку.

Начиная с версии 15 Java поддерживает тестовые блоки (text blocks) — многострочный текст, облеченный в тройные кавычки. Рассмотрим, в чем их практическая польза. Например, выведем большой многострочный текст:

String text = "Вот мысль, которой весь я предан,\n"+ "Итог всего, что ум скопил.\n"+ "Лишь тот, кем бой за жизнь изведан,\n"+ "Жизнь и свободу заслужил."; System.out.println(text);

С помощью операции + мы можем присоединить к одному тексту другой, причем продолжение текста может располагаться на следующей строке. Чтобы при выводе текста происходил перенос на следующую строку, применяется последовательность \n.

Результат выполнения данного кода:

Вот мысль, которой весь я предан, Итог всего, что ум скопил. Лишь тот, кем бой за жизнь изведан, Жизнь и свободу заслужил.

Текстовые блоки, которые появились в JDK15, позволяют упростить написание многострочного текста:

String text = """ Вот мысль, которой весь я предан, Итог всего, что ум скопил. Лишь тот, кем бой за жизнь изведан, Жизнь и свободу заслужил. """; System.out.println(text);

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

Основные отличия примитивных типов от непримитивных в Java

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

Примитивные типы

  • Выигрыш в производительности.

Оболочки (обертки) типов

  • Являются частью объектной иерархии.
  • Необходимы в случаях когда класс может работать только с объектами.
  • Удобство использования таких полей как MAX_VALUE и.т.д.

P.S.
Прекрасный ответ о причинах введения автоматической автоупаковки/распаковки.

Отслеживать
ответ дан 3 мар 2017 в 20:09
Sanek Zhitnik Sanek Zhitnik
2,212 2 2 золотых знака 17 17 серебряных знаков 28 28 бронзовых знаков

Непримитивные являются классами, потомками Object. Соответственно, передаются по ссылке. К ним применяются все правила работы с классами и объектами. Это часто бывает нужно, если их нужно передать в качестве аргумента методу, принимающему Object. Или указать в качестве параметра типа для Generic-а. Например, List . Но не может быть List .

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

EDIT: Важно не путать, что именно мы передаём по значению, а что — по ссылке. Любая переменная ссылочного типа (reference type) хранит в себе ссылку на объект или null, если она не связана с объектом. Так же, как и в случае с переменной примитивного типа, переменная ссылочного типа передаётся по значению. В этом смысле разницы между ними нет.

Однако большая разница возникает, когда думаем о передаче примитива и объекта (или массива).

Передавая примитивное значение, в вызванном методе мы теряем всякую связь с прежней переменной, содержавшей это значение, и никак на неё повлиять не можем.

Однако, передавая ссылку, мы получаем ключ к объекту или массиву, что в общем случае создаёт проблему shared mutable state и может привести к разного рода «сюрпризам», когда объект-владелец переменной внезапно обнаруживает (или даже и не обнаруживает), что значение его атрибута изменилось.

С помощью специальных методик проектирования классов (или специальных библиотек с такими классами) можно добиться того, чтобы однажны созданные экземпляры ссылочных типов было (почти) невозможно изменить. Ключевые слова: immutable type, persistent type, value object. В языках JVM, ориентированных на функциональное программирование, такие типы входят в базовую библиотеку. В самой Java таким образом реализованы, например, обёртки над примитивными типами и String.

Ссылочные типы данных — 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 студентов

Наши выпускники работают в компаниях:

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *