Что такое примитивные типы java

Познаём Java. Третья чашка: примитивные типы, и объекты. Базовые конструкции

Типа реальные типы

Думаю, после краткого экскурса в возможности Java и прочитывания пары десятков строк кода примеров, вам захотелось узнать, чем должен уметь оперировать каждый Java-программист. Что ж, давайте поговорим о примитивных типах, классах (в том числе нескольких основных), сравнении, передаче параметров и простых структурах в Java.

Базовые типы

вы получите именно 200, а не что-то ещё — переменные будут автоматически приведены к нужному типу.
Есть несколько способов задавать значение целочисленным переменным, например:

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

Операции с базовыми типами

Сравнение

Почему нельзя писать == для объектов

Это чудо вернёт вам 3 раза false. Потому что мы явно указали создание новых объектов с одним значением, и сравнение по ссылке вернуло false.
А в первых двух случаях произошло развёртывание, так как операция сравнения определена только для примитивных типов.
Мораль: == только для примитивных типов.

«Кстати, строки»

Здесь, как вы видите приведены 2 способа инициализации, второй при этом хоть и избыточен, но гарантирует что ваша строка будет «новой».
Строго говоря, любая конструкция в Java в двойных кавычках — уже новая строка, созданная и закешированная (см. ниже).

Кроме того, для строк есть операция соединения (конкатенации):
String r = «Привет » + «мир»;

Конструкторы, ссылки и значения: куда что идёт, и куда оно уходит.

Когда вы создаёте новый объект, вы начинаете его жизненный цикл.
Начинается он с вызванного вами конструктора. Да? Нет.

При первом упоминании класса вызываются по порядку все его статик-блоки вида static <. >лежащие в классе.
Статик-блоки родителей вызываются по мере их упоминания.
Затем вызываются по порядку все блоки вида <. >верхнего родителя.
Далее — вызывается конструктор этого же родителя.
Затем последние 2 шага повторяются для каждого класса иерархии.
В последнюю очередь вызываются <>-блоки и конструктор вашего класса.

Далее — ваш объект живёт до тех пор, пока на него есть ссылки.
Как только ссылки на объект теряются — он подхватывается сборщиком мусора и уничтожается. Никаких a = null чтобы «стереть ссылку» писать не нужно — java и так знает, когда вы перестали использовать объект.
Перед уничтожением вызывается метод finalize вашего милого объекта.

Кстати, иногда встречается такая ошибка: человеку в метод передают некий объект, а он присваивает ему null, думая, что таким образом он объект сотрёт из всех ссылок. Нет, этого не будет, будет уничтожена только это ссылка. Однако, если ссылка была всего одна — разумеется, в этом случае объекту придёт конец.

Как выбираются конструкторы.

В предыдущем параграфе были упомянуты конструкторы. Их у класса может быть много, у каждого — свои параметры.
По умолчанию, если вы ручками не написали ни одного, то будет создан пустой конструктор без парамертов.
Каждый из них обязан вызывать конструктор класса-родителя.
Чтобы это сделать, вы должны дописать первой строкой в конструктор super-вызов:

public HelloWorld() <
super();
>

super-конструктор — это конструктор родителя. Вы можете использовать любой, из тех что у него есть.
На самом деле, если вы его не напишете — за вас это сделает компилятор. А что будет если у класса-родителя нет конструктора без параметров?
В этом случае вы должны явно вызывать super-конструктор всегда, и передавать ему параметры как для конструктора класса-родителя.

Что у вас там про кеширование?

Я упоминал кеширование объектов. Немного поясню. Дело в том, что упоминание чисел/строк — рутина, которая сваливается на нас постоянно. Чтобы не хранить в памяти тысячу интеджеров с 1 в качестве значения был сделан механизм кеширования. Он гарантирует вам, что на каждую вашу еденичку или строку будет создан ровно один объект в памяти, а при автоматическом развёртывании он и будет использован. Шутка в том, что разработчики платформы ограничили количество кешируемых чисел пределами, упомянутыми выше.

«Кстати, строки», часть 2 — будьте аккуратны.

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

Массивы

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

Базовые конструкции Java

if(любое boolean-выражение или переменная)<>else<>
for(действия до начала цикла; условие продолжения цикла; действие после каждого шага)<>
while(условие продолжения цикла)<>
do<>while(условие продолжения цикла)
switch(переменная числового или enum)
for(Тип имяПеременной: массив)<>

На последнем хотел бы остановиться подробнее. В Java так выглядит цикл for-each. Он перебирает каждый элемент массива, например так:

Кроме того, for-each применим для любой коллекции, и не только для них. Об этом расскажу потом.

Источник

H Примитивные типы в Java в черновиках Tutorial

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

Примитивные типы немного нарушают объектную ориентированность языка Java, так так представляют одиночные (простые) значения. Эта особенность объясняется желанием обеспечить максимальную эффективность. Создавать объект простой переменной с помощью new недостаточно эффективно, так как new перемещает объект в кучу. Вместо этого создается «автоматическая» переменная, которая не является ссылкой на объект. Переменная хранит единственное значение и располагается в стеке. Стек — это область хранения данных, расположена в RAM. Процессор имеет прямой доступ до этой области через указатель на стек, поэтому стек — очень быстрый и эффективный способ хранения данных. По скорости стек уступает только регистрам (логично, так как регистры расположены внутри процессора).
Все размеры примитивных типов строго фиксированы и не зависят от машинной архитектуры. Это одна с причин улучшенной переносимости Java-программ.
В Java определено восемь примитивных типов, которые можно разбить на четыре группы:

Целые числа

Числа с плавающей точкой

Символы

В спецификации примитивный тип char принадлежит к целочисленным типам (или integral types), но поскольку он играет немного другую роль, можно выделить для него собственную категорию. Его роль — представлять символы Unicode. Для хранения символов требуется 16 бит. Странно, ведь для представления символов основных языков (например, английского, французского, испанского) достаточно 8 бит. Но такая цена интернационализации. Unicode использует полный набор международных символов на всех известных языках мира.

Логические азначения

Примитивный тип boolean предназначен для хранения логических значений. Данный тип может принимать одно из двух возможных значений: true (истина) или false (ложь). Значения boolean возвращаются со всех логических операций (например, операции сравнения). Является обязательным при построении циклов, операторов (например, for, if).

Литералы

Значения примитивных типов данных в большинстве случаев инициализируются с помощью литералов. Рассмотрим их.

Целочисленные литералы

Наиболее часто используемые литералы. Любое целочисленное значение является числовым литералом (например, -10, 10 — десятичные значения). Можно использовать восьмеричные, шестнадцатеричные и двоичные литералы:

Все целочисленные литералы представляют значения int. Если значение литерала лежит в диапазоне byte, short или char, то его можно присвоить переменной этого типа без приведения типов. Для создания литерала типа long, необходимо явно указать компилятору, дополнив литерал буквой ‘l‘ или ‘L‘:

Литералы с плавающей точкой

Существует две формы записи литеров с плавающей точкой: стандартная и экспоненциальная:

Всех литералам с плавающей точкой по-умолчанию присваивается тип double. Поэтому чтобы создать литерал типа float, нужно после литерала указать букву ‘f‘ или ‘F‘. К литералам также можно добавлять букву ‘d‘ или ‘D‘, сообщая, что это литерал типа double, но зачем?

Можно использовать шестнадцатеричные литералы с плавающей точкой, например:

Для удобности чтения длинных литералов в 7 версии языка была добавлена возможность использовать символ ‘_’ внутри литерала:

Символьные литералы

Символьные литералы заключаются в одинарные кавычки. Все отображаемые символы можно задавать таким способом. Если символ нельзя ввести непосредственно, используют управляющее последовательности начинающиеся с символа ‘\‘. Хотя все эти последовательности можно заменить соответствующим Unicode кодом. Также символьный литерал можно создать используя восьмеричную (‘\xxx’) и шестнадцатеричную форму (‘\uxxxx’).

Существуют также строковые литералы. Информацию о них можно получить тут.

Логические литералы

С логическими операторами все просто. Существует только два логических литерала:

Логические литералы можно присваивать только переменным типа boolean. Также важно понимать, что false не равен 0, а true не равен 1. Преобразовать переменную типа boolean в другие примитивные типы не выйдет.

Операции

Над целочисленными типами

Над Floating-Point типами

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

Над логическим типом

Преобразование

Существует три типа преобразований:

Расширяющее преобразование

Если оба типа совместимы и длина целевого типа больше длины исходного типа выполняется расширяющее преобразование (например byte преобразуется в int). Следующая таблица демонстрирует все возможные расширяющее преобразования. Курсовом помечены типы, преобразования в которые, возможно, приведут к потери данных.

Суживающее преобразование

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

Чтобы выполнить преобразование двух несовместимых типов необходимо воспользоваться приведением (casting). Если значения исходного целочисленного типа больше допустимого диапазона значений целевого типа, то оно будет сведено к результату деления по модулю на диапазон целевого типа. Если же значения типа с плавающей точкой приводится к значению целочисленного типа, то происходит усечение (отбрасывается дробная часть).

Продвижение

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

Правила продвижения хорошо демонстрирует следующая диаграмма:

Классы-обертки

Для представления примитивных типов как объектов было сделаны классы-обертки (wrapper classes). Какие преимущества дают нам классы-обертки?

Автоупаковка и распаковка

В версии JDK 5 были введены два важных средства:

Некоторые полезные методы

Спасибо за внимание. Все дополнения, уточнения и критика приветствуются.

Источник

Java/Типы данных

Содержание

Примитивные типы [ править ]

В Java есть 8 примитивных типов, которые делят на 4 группы, вот они:

Целочисленные типы [ править ]

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

Пример использования целочисленных типов:

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

Типы с плавающей точкой [ править ]

Логический тип [ править ]

В стандартной реализации Sun JVM и Oracle HotSpot JVM тип boolean занимает 4 байта (32 бита), как и тип int. Однако, в определенных версиях JVM имеются реализации, где в массиве boolean каждое значение занимает по 1-му биту.

Ссылочные [ править ]

Строки [ править ]

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

Обертки [ править ]

Если требуется создать ссылку на один из примитивных типов данных, необходимо использовать соответствующий класс-обертку. Также в таких классах есть некоторые полезные методы и константы, например минимальное значение типа int можно узнать использовав константу Integer.MIN_VALUE. Оборачивание примитива в объект называется упаковкой (boxing), а обратный процесс распаковкой (unboxing).

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

Получить примитив из объекта-обертки можно методом Value.

Источник

Введение в примитивы Java

Изучите основы примитивных типов данных Java.

1. Обзор

Язык программирования Java содержит восемь примитивных типов данных.

В этой статье мы вспомним, что такое примитивы, и рассмотрим их.

2. Примитивные Типы Данных

Они хранятся непосредственно в стеке (проверьте эту статью для получения дополнительной информации об управлении памятью в Java).

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

Давайте начнем с краткой справки:

2.1. int

Мы можем просто объявить int просто:

Значение по умолчанию инт объявлено без присвоения равно 0.

Если переменная определена в методе, мы должны присвоить ей значение, прежде чем использовать ее.

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

2.2. байт

Мы можем создать байт :

Значение по умолчанию байт также равно 0.

2.3. короткие

short объявляется следующим образом:

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

2.4. длинные

Мы можем просто объявить один:

2.5. поплавок

Мы объявляем float s таким же, как и любой другой тип:

Мы также можем выполнять все стандартные арифметические операции над float s. Однако важно отметить, что мы выполняем арифметику с плавающей запятой совсем иначе, чем целочисленную арифметику.

2.6. двойной

Далее мы рассмотрим double – его название происходит от того, что это десятичное число двойной точности.

Объявление double – это то же самое, что и другие числовые типы:

Значение по умолчанию также равно 0.0, как и в случае с float. Аналогично float, мы прикрепляем букву D для обозначения литерала как двойника.

2.7. булево

Однако для удобства Java заполняет значение и сохраняет его в одном байте.

Объявите boolean вот так:

2.8. char

Давайте теперь объявим a char :

При определении наших переменных мы можем использовать любой символьный литерал, и они автоматически преобразуются для нас в свою кодировку Unicode. Значение по умолчанию для символов равно ‘/u0000’.

2.9. Переполнение

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

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

Переполнение чисел с плавающей запятой путем возврата бесконечности. Когда они уменьшаются, они возвращают 0.0.

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

2.10. Автобоксинг

3. Заключение

В этом уроке мы рассмотрели восемь примитивных типов данных, поддерживаемых в Java.

Это строительные блоки, используемые большинством, но не всеми программами Java, поэтому стоит понять, как они работают.

Источник

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

Продолжаем серию уроков по программированию на языке Java. И сегодня пора нам написать чуть более сложное приложение, чем «Hello world». Мы будем говорить о типах данных.

Java является строго типизированным языком программирования. Это означает, что переменные имеют конкретный известный тип еще на этапе компиляции. Например, если мы возьмем язык Javascript, то там можно объявить переменную как «var a = 45» или «var b = «Hello». То есть тип переменной здесь не указывается. В Java же, напротив. Если мы хотим объявить некую переменную, нам нужно указать ее тип, чтобы компилятор знал с каким типом он работает. Закрепим прочитанное примером. Откройте наш первый проект, который мы создали в статье о первом приложении и создайте новый класс. Назовем его TypesOfData. Не забудьте при создании поставить галочку, чтобы создался метод main. Теперь можно создать пару переменных. Хм.. Но мы не сможем ничего создать, так как ничего еще не выучили. Нужно еще немного теории.

В Java есть 8 примитивных типов, которые делят на 3 группы, вот они:

Целочисленные типы данных

Типы с плавающей точкою. То есть дробные

Логический тип данных

Предлагаю пока поработать с целочисленными типами. Самым «популярным» среди целочисленных типов данных является тип int. Он позволяет хранить достаточно большой диапазон чисел и занимает не всего 32 бита.

Подкрепив наши знания теорией давайте воплотим их на практике. Для этого создайте несколько глобальных переменных в своем классе. Забыл упомянуть, что в Java переменные делятся на глобальные и локальные переменные. Глобальные — это те которые объявленные в классе. Локальные — те которые объявленные в методе. Об их разнице мы поговорим позже.

Вот пример объявленных глобальных приложений. Как Вы могли заметить, я называю переменные и классы в так называемом CamelCase или верблюжий регистр. Это не просто так. Дело в том, что в Java принято объявлять переменные, классы и методы именно в таком стиле. Я советую Вам начать программирование с правильного стиля, который принятый в сообществе программистов для того, чтобы Ваш код могли читать и редактировать другие люди. Также старайтесь называть переменные, методы и классы в читаемом стиле: для класса — это сущность, которую он изображает, для метода — действие, для переменной — читаемое имя, которое ей соответствует.

Мы немного отошли от темы. Давайте теперь попробуем поработать с примитивными типами. Что же можно делать с типами данных в Java? Да все что угодно: добавлять, присваивать им другие значения, отнимать, делить и т.д. Об операциях мы поговорим в следующей статье, так как она очень увеличит данную статью.

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

public class TypesOfData <

public static void main ( String [ ] args ) <
byte byteVariable = 3 ;

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

Источник