Курс Java Syntax PRO Comics


1. Тип

int

Если вы хотите хранить в переменных целые числа, вам нужно использовать тип int.

int — это сокращение от Integer (целый с английского), что как бы намекает, что этот тип позволяет хранить целые числа.

Переменные типа int способны хранить целые числа в диапазоне от -2 миллиарда до +2 миллиарда. Или, если быть более точным, то от -2,147,483,648 до 2,147,483,647.


2. Создание переменной типа

int

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

int имя;

Объявление переменной типа int

Где имя — это имя переменной. Примеры:

КомандаОписание
int x;
Создается целочисленная переменная x
int count; 
Создается целочисленная переменная count
int currentYear;
Создается целочисленная переменная currentYear

Размер (регистр) букв имеет значение: команды int color и int Color объявят две разные переменные.

Команды же Int Color и INT COLOR компилятор вообще не поймет и сообщит об ошибке. int — это специальное слово, обозначающее целый тип, и пишется оно только строчными буквами.


3. Краткая запись создания переменных

Если в одном месте программы нужно создать много переменных одного типа, это можно сделать, используя сокращенную запись:

int имя1, имя2, имя3;

Краткая запись создания нескольких переменных одного типа

Примеры:

КомандыКраткая запись тех же команд
int x;
int y;
int z;
int x, y, z;
int count;
int totalCount;
int count, totalCount;
int day;
int month;
int year;
int day, month, year;

4.

Присваивание значений

Чтобы занести значение в переменную типа int, нужно воспользоваться командой:

имя = значение;

Присваивание значения переменной

Где значением может быть любое целочисленное выражение. Примеры:

КомандаПримечание
int a;
a = 5;
int b;
b = 2*1000*1000*1000;
int c;
c = -10000000;
int d;
d = 3000000000;
Не скомпилируется, т.к. 3,000,000,000 больше, чем максимально возможное значение типа int 2,147,483,647

5. Сокращенная запись создания и инициализации переменной

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

Выглядит эта команда так:

int имя = значение;

Краткая запись создания и инициализации переменной

Примеры:

КомандаПримечание
int a = 5; 
int b = 2*1000*1000*1000;
В переменной будет значение «2 миллиарда»
int c = -10000000;
В переменной будет значение «минус 10 миллионов»
int d = 3000000000; 
Не скомпилируется, т. к. 3,000,000,000 больше, чем максимально возможное значение типа int: 2,147,483,647

Можно объявить и несколько переменных одной строкой. Тогда команда будет иметь вид:

int имя1 = значение1, имя2 = значение2, имя3 = значение3;

Краткая запись создания и инициализации нескольких переменных

Примеры:

КомандаПримечание
int a = 5, b = 10, c = a + b;
a равно 5, b равно 10, c равно 15
undefined

Баги робокопа

Амиго, похоже пришла пора нам вмешаться! Сейчас я проверю код этого полицейского робота.

Похоже тут снова проделки галабагов!


undefined

«Я по объявлению…»

В методе main объяви переменные intValue, numericValue, size, number типа int. Присвой им разные значения. Используй одну команду для создания и инициализации переменных. Значениями могут быть любые целые числа.

Переменные в Java • Vertex Academy

Vertex Academy boolean,byte,char,double,float,integer,long,переменные java,создание переменных,типы переменных Java

Данная статья:

  • написана командой Vertex Academy. Надеемся, что она Вам будет полезна. Приятного прочтения!
  • это одна из статей из нашего «Самоучителя по Java»

Что такое переменная в Java?

Часто Вы можете услышать такое определение переменной:

  • Переменная — это некоторый контейнер,  в котором может храниться значение для дальнейшего использования в программе.

Помните, как в школе было:  y = x + 1

И в зависимости от того, какие значения принимает переменная x, меняется значение переменной y.

Если x = 1, тогда x+ 1 =2

Если x = 2, тогда x +1 = 3

Если х = 1.5 , тогда x + 1 =2.5

В Java переменные играют такую же роль, как и в приведенном примере со школы y =  x + 1. Они выполняют роль контейнера для разных значений, которые можно подставить в переменную. В приведённом примере — в переменную x.

Типы переменных в Java. Объявление переменной

В Java можно указать, какие именно значения может принимать переменная.

Для этого все переменные сгруппировали в 4 группы:

  1. Целочисленные (к ним относятся byte, short, int, long)
  2. С плавающей точкой (к ним относятся float, double)
  3. Символы (char)
  4. Логические (boolean)

Примечание:  Итого 8 типов переменных (byte, short, int, long, float, double, char, boolean). Многоуважаемый Брюс Эккель выделяет еще и 9-й тип – так называемый тип void («пустое» значение). Но в этой статье мы рассмотрим 8 типов, как это обычно принято. Что же такое тип void мы разберёмся в теме, посвященной методам в Java.

Теперь давайте рассмотрим каждую группу переменных. И начнём с целочисленных.

Целочисленные: byte, short, int, long

Как видно из таблички, byte, short, int, long относятся к целочисленным, то есть к целым числам. Например, 1, 9, 1278, -5, -107 и т.д.

Очевидно:

  1. byte может принимать значения от -128 до 127 и при этом занимает 1 байт памяти
  2. short принимает значения от -32768 до 32767 и занимает 2 байта памяти
  3. int от -2147483648 до 2147483647 и занимает 4 байта памяти
  4. long от -9223372036854775808 до 9223372036854775807 и занимает 8 байтов памяти

«Ну, хорошо», — скажете Вы. «Если byte, short, int и long отвечают все за целые числа, как мне понять какой именно тип нужно выбирать?» Помните детские задачки по математике, которые сейчас будут как нельзя кстати для объяснения за что отвечают byte, short, int, long.

Задача 1:

У Димы 3 яблока, у Ани 2 яблока. Сколько яблок у Димы и Ани вместе?

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

Значит, если бы мы писали код в Java, который бы предполагал решение данной задачи, мы бы использовали для переменных целочисленный тип. Остается понять только какой именно мы бы использовали: byte, short, int или long?

Всегда необходимо отталкиваться от контекста.

  1. Если мы знаем точно, что при решении данной задачи, даже если будут меняться значения, например, у Димы 50 яблок, у Ани 30, но в сумме это будет не больше 127 яблок, то можем смело использовать тип byte
  2. Если же мы знаем, что могут поменять условия задачи и у Димы может быть, например, 10 000 яблок, а у Ани, например, 7 000 яблок, то уже тип byte мы использовать не можем. Поскольку это явно выходит за пределы допустимых значений в byte – не более 127.  Значит, могли бы использовать тип short, у которого максимально допустимое значение 32767
  1. Если же предположить, что у Димы и у Ани может быть даже больше, чем 32767 яблок. Ну, например, у них яблоневые сады по всей Украине. Тогда необходимо использовать тип int. Кстати, int – это сокращенно от английского integer (целое число).
  2. Ну, а если предположить, что Дима и Аня – это «яблочные магнаты» и им принадлежат все яблоневые сады в мире, то тогда число может быть намного больше, чем даже максимальное значение int 2147483647. И тогда необходимо использовать тип long.

Однако чаще всего при написании программ на Java, Вы будете использовать тип int. Это самый распространенный целочисленный тип. Более того, тип int в Java является типом «по умолчанию» для целочисленных типов. Что это значит, Вы узнаете на практике.

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

А вот и примеры объявления переменных:

byte apples;

short apples;

int apples;

long apples;

И здесь сразу же хочется сказать о том, что переменные, когда их название состоит из 2 и более слов, пишутся слитно и  как бы «горбиками» как у верблюда. Такой стиль написания слов называется CamelStyle (от англ. camel — «верблюд»).

 

Например:

int applesDima;

int applesAnnaJune;

int applesDimaJuneUkraine;

Видите, названия примеров переменных состоят из 2 и более слов и пишутся слитно. Причем первое слово пишется с маленькой буквы, а во всех последующих словах первая буква большая. Теперь Вы знаете — это CamelStyle, стиль написания названий. Он иногда называется CamelCase. Мы об этом даже статью написали 🙂

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


С плавающей точкой: float, double

И снова обратимся к примеру школьной задачи.

Задача 2:

У Димы 3,5 яблока, у Ани 2,5 яблока. Сколько яблок у Димы и Ани вместе?

Как видите, в задаче речь идёт уже не о целых яблоках.  Уже речь идёт о дробных числах. А значит мы уже не можем использовать целочисленный тип: нам не подойдет ни byte, ни short, ни int, ни long. Запомните: как только речь идет о дробных числах, значит, речь идет о float или double. Примеры дробных чисел: 1.0, 1.8, 3.141562, 9.0, 12.579, 1278.0, -5.0, — 9.4, -107.0, -107.356 и т.д.

Как видно из таблички:

  1. float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
  2. double принимает значения от -1.7E + 308 до 1.7Е + 308 и занимает 8 байт памяти

Запомните:

  • дробные числа пишутся не через запятую, как мы привыкли со школы, а через точку. Например,  1,5 — это неправильно. Правильно 1.5
  • float определяет значение одинарной точности. Это значит, что переменные данного типа удобны, когда требуется дробная часть без особой точности. Например, для денежных сумм.
  • double обеспечивает двойную точность и это видно из названия (double — двойная).

Прежде, чем использовать переменную, её необходимо объявить. А объявляются переменные float и double по такому же принципу.

А вот и примеры объявления переменных:

float money; // объявили переменную money типа float

float wage; // объявили переменную wage типа float

float c; // объявили переменную c типа float

double stat; //объявили переменную stat типа double


 Символы: char

В Java для char используется кодировка Unicode. Как видно из таблички, диапазон допустимых значений char от 0 до 65536 и при этом занимает 2 байта памяти. Отрицательных значений не существует. На самом деле переменная типа char хранит не сам символ, а его числовой код из таблички Unicode, по этому мы можем проводить целочисленные операции над символами.

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

Примеры объявления переменных:

char y; //объявили переменную y типа char

char f; //объявили переменную f типа char


Логические: boolean

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

Только у славян возможен такой разговор:

— Кушать будешь?

— Да нет, наверное.

Это то, что очень удивляет иностранцев, когда они учат, например, украинский или русский язык. Так все-таки да или все-таки нет?

Так вот в языке программирования Java всё очень точно:

  • либо true (с английского — «истина»)
  • либо false (с английского — «ложь)

Чуть позже Вы поймете где применяется данный тип переменных, когда мы, например, дойдём до темы конструкции ветвления. А пока просто запомните, что есть такой тип. Пусть это будет пока «черной лошадкой» для Вас.

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

Примеры объявления переменных:

boolean check1; //объявили переменную check1 типа boolean

boolean check2; //объявили переменную check2 типа boolean


 

Ну вот, теперь Вы знаете за что отвечают эти типы переменных:

Что ещё Вы должны знать?

1. Вы должны знать, что эти типы переменных относятся к так называемым примитивным типам переменных. Поэтому если услышите «примитивные типы данных» , «примитивы» или «primitives», знайте, речь идёт о 8 типах переменных — byte, short, int, long, float, double, char, boolean.

2. Есть еще один тип переменных — тип String. О нём мы поговорим в статье «Как присвоить значение переменной»

3. В Java очень важно правильно оформлять код. Да-да, не только писать работающие программы, но  ещё и правильно оформленные. Существует целый свод правил, который называется Code Conventions в Java. Так что можете смело скачивать и постепенно изучать. А сейчас мы рассмотрим только часть Code Conventions, а именно правила написания названий переменных. Итак, запоминаем.

5 правил выбора названий для переменных:

Правило №1 —  переменные пишутся только латинскими буквами. Никакой кириллицы!!!

Например:

int st;

int width;


Правило №2 – имя переменной, по возможности, должно быть «говорящим»

Например:

int s; // так можно называть переменную, но когда кода много и все переменные имеют не говорящие названия, код очень тяжело читать

int size; // этот вариант более «говорящий», чем первый вариант int s; поскольку понятно из названия, что переменная отвечает за размер чего-то


Правило №3 —  с чего может/не может начинаться имя переменной

 Может начинаться с :

  1. Любых латинских букв
  2. $ или _

Не может начинаться с:

  1. Цифр

Ниже приводим несколько примеров — правильных и неправильных.

Правильно:

  • int square;
  • int $money;
  • int width;
  • int boxSize;
  • double sum;
  • double sumJune;

Неправильно:

  • int 2square;
  • int 101dalmatians;

Правило №4 – название переменной, состоящее из 2 и более слов, пишется в CamelStyle

Что такое CamelStyle мы с Вами уже обсудили в этой статьей чуть выше.


Правило №5 – нельзя использовать в названиях переменных эти 54 слова:

abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while

Эти 54 слова имеют особое значение при написании кода на Java. Постепенно Вы поймёте где используется каждое слово. Причём после прочтения этой статьи, из 54 слов Вам уже станут знакомы те слова, которые мы выделили синим:

abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while


ПОДЫТОЖИМ:

Всего 4 группы переменных:

  1. Целочисленные (к ним относятся byte, short, int, long)
  2. С плавающей точкой (к ним относятся float, double)
  3. Символы (char)
  4. Логические (boolean)

Эти 8 типов переменных (byte, short, int, long, float, double, char, boolean) относятся к там называемым примитивным типам переменных.

Прежде чем использовать переменную, её необходимо объявить:

5 правил выбора названий переменных:

  1. Переменные пишутся только латинскими буквами. Никакой кириллицы!!!
  2. Имя переменной, по возможности, должно быть «говорящим»
  3. Если переменная состоит из 2 и более слов, пишется в CamelStyle (другое название — CamelCase)
  4. Есть 54 слова, которые нельзя использовать в названиях переменных
  5. Имя переменной:
  • может начинаться с любых латинских букв, $ или _
  • не может начинаться с цифр

Также есть еще один тип переменных — тип String, о котором мы поговорим в статье «Как присвоить значение переменной в Java»


Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля.

По всем вопросам звоните:

+38 050 205 77 99

+38 098 205 77 99

Или читайте информацию по нашим курсам Java c нуля у нас на сайте.


404: Страница не найдена

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

Что я могу сделать сейчас?

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

Поиск
  • Узнайте последние новости.
  • Наша домашняя страница содержит самую свежую информацию о Java-разработке.
  • Наша страница «О нас» содержит дополнительную информацию о сайте, на котором вы находитесь, TheServerSide.com.
  • Если вам нужно, свяжитесь с нами, мы будем рады услышать от вас.

Просмотр по категории

Архитектура приложения

  • Как выжить, когда царит развитие Waterfall

    Несмотря ни на что, методология Waterfall поддерживает бесчисленное количество команд разработчиков программного обеспечения.

  • Необработанный, но растущий потенциал банковского обслуживания без ядра

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

  • Основы достижения высокой сплоченности и низкой связанности

    Легко сказать «высокая сплоченность, низкая связанность», но так ли легко это реализовать на практике? Мы рассмотрим некоторые основы …

Качество ПО

  • Тестовые фреймворки и примеры для модульного тестирования кода Python

    Модульное тестирование является важным аспектом разработки программного обеспечения. Команды могут использовать Python для модульного тестирования, чтобы оптимизировать преимущества Python…

  • Атрибуты эффективной стратегии тестирования базы данных

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

  • Обновления Java 20 Project Loom готовят почву для Java LTS

    Java 20 повторно инкубирует две функции масштабируемости Project Loom, что делает их главными кандидатами на то, чтобы стать стандартом в сентябрьском выпуске Java …

Облачные вычисления

  • 4 рекомендации, чтобы избежать привязки к поставщику облачных услуг

    Без надлежащего планирования организация может оказаться в ловушке отношений с облачным провайдером. Следуйте этим …

  • Подходит ли вам облачная стратегия?

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

  • Как использовать сценарии запуска в Google Cloud

    Google Cloud позволяет использовать сценарии запуска при загрузке виртуальных машин для повышения безопасности и надежности. Выполните следующие действия, чтобы создать свой…

Безопасность

  • Десктопное приложение 3CX скомпрометировано и использовано в атаке на цепочку поставок

    Клиенты 3CX заметили, что несколько платформ обнаружения угроз начали помечать и блокировать настольное приложение поставщика унифицированных коммуникаций …

  • Уязвимость Azure Pipelines выявляет угрозы цепочки поставок

    Исследователи Legit Security обнаружили уязвимость удаленного выполнения кода в платформе Microsoft Azure DevOps, которая может дать …

  • Google: поставщики шпионского ПО используют iOS и Android нулевого дня

    Недавние кампании, за которыми наблюдала группа Google по анализу угроз, показали, что поставщики шпионского ПО используют нулевые дни и известные уязвимости…

ПоискAWS

  • AWS Control Tower стремится упростить управление несколькими учетными записями

    Многие организации изо всех сил пытаются управлять своей огромной коллекцией учетных записей AWS, но Control Tower может помочь. Услуга автоматизирует…

  • Разбираем модель ценообразования Amazon EKS

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

  • Сравните EKS и самоуправляемый Kubernetes на AWS Пользователи

    AWS сталкиваются с выбором при развертывании Kubernetes: запустить его самостоятельно на EC2 или позволить Amazon выполнить тяжелую работу с помощью EKS. См…

Типы данных Java — числовые данные

Указатель статей
Типы данных Java — числовые данные
Литералы и выражения
Числовой вывод

Страница 1 из 3

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

Современная Java


с NetBeans и Swing

Содержание
  1. Почему Java?
  2. Начало работы с Java
  3. Знакомство с Java — Swing Objects
  4. Написание кода
  5. Программы командной строки
  6. Пользовательский интерфейс — Больше Swing
  7. Работа с классом
  8. Наследование класса Java
  9. Типы данных Java — числовые данные
  10. Типы данных Java — массивы и строки
  11. Создание графического интерфейса Java — контейнеры
  12. Advanced OOP — тип, литье, пакеты
  13. Значение и ссылка 
  14. Java Lambdas, SAM и события

 

Мы уже знаем о переменных и о том, как хранить данные, но нам нужно более внимательно изучить, с какими типами данных работает Java. Во многих отношениях необходимость учитывать «тип» данных является чем-то вроде возврата к ранним дням вычислений, когда мы очень внимательно работали над тем, как хранились данные. Тогда имело значение, сколько памяти вы использовали, и разные способы хранения одних и тех же данных использовались просто из соображений эффективности — зачем использовать два байта, когда достаточно одного? Сегодня такие вопросы гораздо менее важны, но мы по-прежнему работаем с базовыми типами данных, которые были введены тогда.

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

Просто пиши меньше

Большая проблема, с которой часто сталкиваются новички, — это попытка понять, зачем вообще существует вся тема типа данных?

В конце концов, если у вас есть форма для заполнения и в ней есть место для ввода вашей зарплаты, обычно не возникает вопроса о том, какой числовой диапазон можно ввести. Если вам нужно написать 100 000 долларов в год, а места мало, просто напишите меньше.

Этот подход не работает для компьютера. Все в компьютере хранится в виде двоичного числа или последовательности битов, что еще более фундаментально. Каждая ячейка памяти имеет фиксированное количество битов, и это ограничивает именно то, что вы можете хранить. Например, один байт данных — это всего восемь битов, а это означает, что вы можете хранить последовательность битов, которую можно интерпретировать как число от 0 до 255, то есть от 00000000 до 11111111. Это звучит нормально, но как насчет отрицательных чисел? Если вы хотите сохранить отрицательные числа, вы должны указать более половины диапазона для отрицательных чисел и половину для положительных. То есть вы могли бы сказать, что от 0 до 127 являются положительными значениями, а от 128 до 255 — отрицательными значениями, от -1 до -127.

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

Например, если вы используете один байт для хранения восьмибитной последовательности, вы можете использовать его для кодирования положительных чисел от 0 до 255 и просто игнорировать возможность наличия отрицательных чисел. В качестве альтернативы вы можете рассматривать битовые последовательности как коды букв алфавита от A до Z и от a до z плюс цифры и другие символы. В первом случае имеет смысл добавлять и выполнять арифметические действия с битовыми последовательностями, но во втором случае действительно не имеет смысла добавлять битовую комбинацию для A к битовой комбинации для a.

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

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

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

Номера

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

Вы можете хранить число в переменной, но для представления числа используются разные форматы, и каждый формат занимает разный объем памяти. Мы рассмотрели основы числовых типов в главе Java — программы командной строки, но есть еще что сказать.

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

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

Стандартные целочисленные типы данных Java:

  • байт 1 байт от -128 до 127
  • короткие 2 байта от -32 768 до 32 767
  • целое число 4 байта от -2 147 483 648 до 2 147 483 647
  • длинный 8 байтов от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807

Вы можете видеть, что размер byte довольно ограничен, но long должно быть более чем достаточно для чего угодно, хотя вы обнаружите, что в вычислениях никогда не бывает достаточно больших размеров.

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

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

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

Чтобы объявить переменную одного из целочисленных типов, вы должны использовать форму:

переменная типа = начальное значение;

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

.

int myInteger=100;

или

целое мое целое число;

Чтобы объявить байтовую переменную, вы должны использовать:

байт myByte=127;

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

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

Плавающая точка

Конечно, вы, вероятно, захотите использовать числовые значения, которые состоят из дробных частей.

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

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

  • с плавающей запятой 4 байта 7 десятичных цифр
  • двойной 8 байт 16 десятичных цифр

Если вам действительно не нужно экономить память по какой-либо причине, использование double является и должно быть значением по умолчанию — точность 7 цифр не так уж много, и дополнительное хранилище стоит использовать.

Как и в случае целочисленных типов, типы с плавающей запятой объявляются с использованием:

с плавающей запятой myFloat=0,123;
двойной myDouble=0,123;

Обратите внимание, что типы с плавающей запятой не подходят для записи точных значений в большом диапазоне, например валюты.

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

Также стоит знать, что, хотя числа отображаются в десятичном виде, когда вы их распечатываете, на самом деле они хранятся в двоичном формате. Это действительно вызывает проблему только тогда, когда мы используем десятичные дроби. Проблема в том, что в любой данной системе счисления некоторые дроби могут быть выражены точно, а в других системах счисления те же дроби не могут быть выражены. Например, в десятичном виде вы можете сказать, что 1/10 равно 0,1, но 1/3 доставляет больше хлопот, потому что это 0,33333.