Что такое значение переменной в java. Типы переменных в Java и какие когда стоит использовать

Тип данных определяется тремя составляющими:

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

Какие бывают типы данных в Java?

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

В Java типы данных делятся на примитивные и ссылочные.

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

Переменная примитивного типа содержит значение, а ссылочная - адрес объекта в памяти.

Язык Java. время и дата

Составные данные делятся на классы, интерфейсы и массивы. Членами интерфейсного типа являются абстрактные методы и константы. В языке Java типы данных дата и время задаются конструктором Date():

• d = new Date().

Язык Java. Типы данных: String

Строка представляет собой класс, определенный в и он может быть использован для работы с текстом (последовательностью символов).

Объявление ссылочной String-переменной следующее: String str.

• str = new String ("Привет").

Что происходит при выполнении этого кода? Во-первых, выделяется память, и имя str связывается с этой ячейкой памяти. Это не отличается от объявления примитивной переменной. Второй фрагмент кода создает в памяти объект String с текстом «Привет» и сохраняет ссылку на него (или адрес памяти) в str.

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

• String str1;
• String str2;
• str1 = new String ("Привет");
• str2 = str1;

Объект String создается с помощью оператора new. Но так как строки используются часто, есть более простой способ его создания. Все строковые литералы, т. е. последовательность символов, заключенная в двойные кавычки, рассматриваются как объекты String. Поэтому вместо оператора new можно использовать строковые литералы:

• String str1 = "Hello".

Примитивные типы данных Java - byte, short, int, long, char, float, double и boolean. Они делятся на две категории: логическую и числовую. Последняя может быть разделена на целые числа и числа с плавающей точкой.

Целые типы данных Java представляют собой числовые типы, значения которых являются целыми числами. Их пять: byte, short, int, long и char.

Int

Int представляет собой 32-разрядный знаковый примитивный тип данных. Переменная занимает 32 бита памяти. Допустимый диапазон - от -2147483648 до 2147483647 (-2 31 до 2 31 - 1). Все целые числа в этом диапазоне являются целочисленными литералами или константами. Например, 10, -200, 0, 30, 19 являются литералами int. Их можно присвоить переменной int:

• int num1 = 21;

Целые литералы могут быть выражены в виде двоичного, восьмеричного, десятичного и шестнадцатеричного числа.

Когда литерал начинается с нуля и имеет, по крайней мере, две цифры, он считается записанным в восьмеричном формате. 0 и 00 представляют одинаковое значение - ноль.

Все литералы int в формате шестнадцатеричного числа начинаются с 0x или 0x, и они должны содержать хотя бы одну шестнадцатеричную цифру:

• int num1 = 0x123.

Int-литералы в формате начинаются с 0b или 0B:

• int num1 = 0b10101.

Long

Это 64-разрядный знаковый примитивный тип. Используется, когда результат вычислений может превышать диапазон int. Диапазон long - от -2 63 до 2 63 - 1. Все целые числа этого диапазона являются литералами длинного типа.

Чтобы отличать в языке Java типы данных int и long, литерал последнего типа всегда заканчивается L или l.

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

Когда long-литерал присваивается переменной long, компилятор Java проверяет присваиваемое значение и удостоверяется, что оно находится в приемлемом диапазоне; в противном случае произойдет ошибка компиляции.

Поскольку диапазон int меньше, чем у long, значение int-переменной всегда может быть присвоено переменной типа long. Но обратное присвоение невозможно даже в пределах диапазона int. Для этого используется явное указание:

• num1 = (int) num2;

Byte

Byte представляет собой 8-разрядный целый примитивный тип. Его диапазон - от -128 до 127 (-2 7 до 2 7 - 1). Это наименьший целый тип, имеющийся в Java. Как правило, байтовые переменные используются, когда в программе задействовано много значений в диапазоне от -128 до 127, или при работе с бинарными данными. В отличие от литералов int и long, byte-литералы отсутствуют. Тем не менее можно назначить byte-переменной любой int-литерал, так как он перекрывает диапазон байта.

Если значение переменной выходит за пределы диапазона, Java выдаст ошибку компилятора.

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

• b1 = (byte) num1.

Short

Представляет собой 16-разрядный знаковый целый примитивный тип данных. Его диапазон - от -32768 до 32767 (или -2 15 до 2 15 - 1).

Как правило, необходимость в коротких переменных возникает, когда программа использует большое количество значений, которые не превышают указанный диапазон. Short-литерал отсутствует, но возможно присвоение любого литерала int в пределах диапазона short. Значение byte-переменной может быть присвоено всегда. Остальные правила присвоения int или long short-переменной такие же, как для byte.

Char

Char является 16-разрядным беззнаковым примитивным типом данных, который представляет символ Юникода. Отсутствие знака означает, что переменная не может иметь отрицательное значение. Диапазон - от 0 до 65535, что совпадает с кодировкой набора символов Юникода. Литерал представляет значение char и может быть выражен в таких формах:

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

Символ может быть выражен путем заключения его в одинарные кавычки: char C1 = "A". обозначают строковый литерал, который не может быть присвоен char-переменной, даже если строка состоит только из одного символа. Это недопустимо, так как ссылка примитивной переменной не присваивается. Все строковые литералы являются объектами класса String и, следовательно, ссылками, тогда как символьные относятся к примитивному типу.

Литерал, выраженный управляющей последовательностью, записывается в виде обратной косой черты с символом в одиночных кавычках. Всего их 8: ‘\n’, ‘\r’, ‘\f’, ‘\b’, ‘\t’, ‘\\’, ‘\”’, ‘\’’.

Управляющая юникод-последовательность имеет вид "\uxxxx", где \u (обратный слеш, за которым следует строчная u) обозначает ее начало, а хххх представляет ровно четыре шестнадцатеричные цифры кода символа в системе Юникод. Например, "A" имеет значение 65 в десятичной системе и 41 в шестнадцатеричной. Таким образом, этот символ может быть представлен как "\u0041".

Восьмеричная управляющая последовательность записывается в виде "\nnn", где n - восьмеричная цифра (0-7). Диапазон значений - от "\000" до "\377", где 377 8 соответствует 255 10 . Поэтому она используется для представления символов с кодом от 0 до 255, необходимого для совместимости с другими языками программирования. В отличие от юникод-последовательности, где необходимы все четыре шестнадцатеричные цифры, здесь можно использовать 1, 2 или 3 восьмеричные: "\n", "\nn" или "\nnn".

Логический тип

Boolean имеет только два действительных значения: true (истина) и false (ложь). Они называются булевыми литералами. Логическая переменная не может быть приведена к другому типу и наоборот. Java не определяет размер boolean - он зависит от конкретной реализации виртуальной Java- машины.

Типы данных Java с плавающей точкой

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

В языке Java типы данных с плавающей точкой используют 32 бита. Согласно стандарту IEEE 754, это соответствует одинарной точности, которая позволяет представлять, например, числа 1,4 х 10 -45 и 3,4 х 10 38 , причем как положительные, так и отрицательные.

Все которые заканчиваются на f или F, называются float-литералами. Они могут быть представлены в формате десятичного числа и в виде научной нотации. Например:

• float f1 = 3.25F;
• float f2 = 32.5E-1F;
• float f3= 0.325E + 1F.

Тип определяет два нуля: +0.0F (или 0.0F) и -0.0F. Однако для целей сравнения оба нуля считаются равными. Кроме того, им определены два вида бесконечности: положительная и отрицательная. Результаты некоторых операций (например, не определены и представлены специальным значением NaN.

Двойная точность

Для хранения чисел с плавающей точкой double использует 64 бита. Число двойной точности может представлять положительные и отрицательные значения величиной 4,9 х 10 -324 и 1,7 х 10 308 .

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

Давайте сегодня по-быстрому разберемся с типами в Java. Все типы в Java делятся на две группы — это примитивные и ссылочные типы.

Здесь будем разбираться с примитивными типами.

Ну пожалуй самый примитивный тип — это логический тип данных. Он же boolean — самый простой тип данных. Переменная такого типа может хранить лишь два значения: true (истина) или false (ложь). С переменными такого типа можно проводить следующие опреации: «!» — отрицание (not), «&&» — логическое И (and), «||» — логическое ИЛИ (or), «^» — исключающе ИЛИ (xor). Таблицы истинности для этих операций можно .

Дальше целочисленные типы данных. К ним в Java относятся следующие типы: byte , short , int и long . Каждый из этих типов принимает разный диапазон значений, объединяет их только то, что все значения всегда целочисленные. Так для типа byte интеравал от?128 до 127, для типа short от?32768 до 32767, для типа int от?2147483648 до 2147483647 ну и для типа long интервал от?9.2·10 18 до 9.2·10 18 . C ними все просто вычитаем, складываем, делим, умножаем…

Ну и конечно есть типы данных с плавающей запятой, дробные типы. Это float и тип с двойной точностью double . float принимает значения в диапазоне приблизительно от?3.4·10 38 до 3.4·10 38 , а double в диапазоне от?1.8·10 308 до 1.8·10 308 . Помимо этого, для этих типов существуют особые значения +? — плюс бесконечность, -? — минус бесконечность и NaN — не число (например при делении на 0).

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

Int i; float f;

Так же сразу можно указать начальное значение:

Int i = 0; float f = 3.5;

В Java используется неявное преобразование типов. Что это такое? Ну например вы хотите сложить две переменные одна типа int а другая типа float. Тогда ваша переменная типа int будет преобразована к типу float и только после этого произойдет сложение. Соответственно и результат получится типа float. При этом меньший тип всегда преобразуется к бльшему, а целое к дробному. Ну например вот это будет работать:

Int a = 3; float b = 4.5, c; с = a + b;

а вот это нет:

Int a = 3, c; float b = 4.5; с = a + b;

Здесь переменная в которую записывается результат имеет тип int, а сам результат получится типа float. Конечно можно привести один тип к другому вручную. Делается это вот так:

Int a = 3, c; float b = 4.5; c = (int) (a + b);

здесь с помошью записи (int) мы приводим сумму a и b к типу int. Однако понятно, что в целочисленной переменной с не может храниться значение 7.5. При приведении дробных типов к целым дробная часть просто откидывается . Это может послужить причиной некотороых ошибок, поэтому об этом не стоит забывать.

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

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

Помните, как в школе было: 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. Символы (char)
2. Логические (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 является типом "по умолчанию" для целочисленных типов. Что это значит, Вы узнаете на практике.

. А объявляются переменные так.

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

Например:

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 - переменные пишутся только латинскими буквами. Никакой кириллицы!!!

Например:

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

Например:

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

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

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

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

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

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

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

Правильно:

• 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 нуля у нас на .

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

В языке Java понятие беззнаковых чисел отсутствует. Все числовые типы этого языка - знаковые. Например, если значение переменной типа byte равно в шестнадцатиричном виде 0x80, то это число -1.

2.1.1.1. Целые типы

Отсутствие в Java беззнаковых чисел вдвое сокращает количество целых типов. В языке имеется 4 целых типа, занимающих 1, 2, 4 и 8 байтов в памяти. Для каждого типа - byte, short, int и long - есть свои естественные области применения.

Тип byte

Тип byte - это знаковый 8-битовый тип. Его диапазон - от -128 до 127. Он лучше всего подходит для хранения произвольного потока байтов, загружаемого из сети или из файла,

byte b;
byte с = 11;

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

Тип short

Short - это знаковый 16-битовый тип. Его диапазон - от -32768 до 32767. Это, вероятно, наиболее редко используемый в Java тип, поскольку он определен как тип, в котором старший байт стоит первым,

short s;
short t= 129;
Тип int

Тип int служит для представления 32-битных целых чисел со знаком. Диапазон допустимых для этого типа значений - от -2147483648 до 2147483647. Чаще всего этот тип данных используется для хранения обычных целых чисел со значениями, достигающими двух миллиардов. Этот тип прекрасно подходит для использования при обработке массивов и для счетчиков. В ближайшие годы этот тип будет прекрасно соответствовать машинным словам не только 32-битовых процессоров, но и 64-битовых с поддержкой быстрой конвейеризации для выполнения 32-битного кода в режиме совместимости. Всякий раз, когда в одном выражении фигурируют переменные типов byte, short, int и целые литералы, тип всего выражения перед завершением вычислений приводится к int.

int j = 1000;
Тип long

Тип long предназначен для представления 64-битовых чисел со знаком. Его диапазон допустимых значений достаточно велик даже для таких задач, как подсчет числа атомов во вселенной,

long m;
long n = 123;

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

Таблица 2.1. Таблица разрядностей и допустимых диапазонов для различных типов целых чисел

		Разрядность	Диапазон
			-9, 223, 372,036, 854, 775, 808 ... 9, 223, 372, 036, 854, 775, 807
			-2, 147, 483, 648 .... 2, 147, 483, 647
			-32,768 .... 32, 767
			-128 ... 127

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

Числа с плавающей точкой, часто называемые в других языках вещественными числами, используются при вычислениях, в которых требуется использование дробной части. В Java реализован стандартный (IEEE-754) набор типов для чисел с плавающей точкой - float и double и операторов для работы с ними.

Таблица 2.2. Характеристики типов чисел с плавающей точкой

		Разрядность	Диапазон
			1.7e-308 .... 1 .7e+ 308
			3.4e-038 .... 3.4e+ 038

Тип float

В переменных с обычной, или одинарной точностью, объявляемых с помощью ключевого слова float, для хранения вещественного значения используется 32 бита,

float f;
float f2 = 3.14;
Тип double

В случае двойной точности, задаваемой с помощью ключевого слова double, для хранения значений используется 64 бита. Все трансцендентные математические функции, такие как sin, cos, sqrt, возвращают результат типа double,

double d;
double pi = 3.14159265358979323846;

Переменная предоставляется нам именем хранения, чтобы нашей программой можно было манипулировать. Каждая переменная в Java имеет конкретный тип, который определяет размер и размещение её в памяти; диапазон значений, которые могут храниться в памяти; и набор операций, которые могут быть применены к переменной.

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

Тип данных переменная [ = значение], [переменная [= значение], ...] ;

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

Ниже приведены примеры объявления переменной и инициализации в Java:

Int a, b, c; // Объявление трех целых a, b, и c. int a = 10, b = 10; // Пример инициализации. byte b = 22; // Инициализация переменной b типа byte. double pi = 3.14159; // Объявление и присвоение величины пи. char a = "a"; // Переменной a типа char присваивается значение "a".

В этом уроке рассмотрим различные типы переменных, доступных в языке Java. Существует три типа переменных :

• локальные переменные;
• переменные экземпляра;
• статические переменные или переменные класса.

Локальные переменные в Java

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

Пример

«age» - локальная переменная, определяется внутри метода «pupAge()» и области её действия ограничивается только этим методом.

Public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("Возраст щенка: " + age); } public static void main(String args){ Test test = new Test(); test.pupAge(); } }

Будет получен следующий результат:

Возраст щенка: 7

Пример без инициализации

Пример использования «age» без инициализации. Программа выдаст ошибку во время компиляции.

Public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("Возраст щенка: " + age); } public static void main(String args){ Test test = new Test(); test.pupAge(); } }

Это приведёт к следующему сообщению об ошибке во время компиляции:

Test.java:4:variable number might not have been initialized age = age + 7; ^ 1 error

Переменные экземпляра

• Переменные экземпляра объявляются в классе, но за пределами метода, конструктора или какого-либо блока.
• Когда для объекта в стеке выделяется пространство, создается слот для каждого значения переменной экземпляра.
• В Java переменные экземпляра создаются тогда, когда объект создан с помощью ключевого слова «new» и разрушаются тогда, когда объект уничтожается.
• Переменные содержат значения, которые должны ссылаться более чем на один метод, конструктор или блок, или на основные части состояния объекта, которые должны присутствовать на протяжении всего класса.
• Переменные экземпляра могут быть объявлен на уровне класса, до или после использования.
• Модификаторы доступа могут быть предоставлены для переменных экземпляра.
• Переменные экземпляра в Java являются видимыми для всех методов, конструкторов и блоков в классе. Как правило рекомендуется сделать их private (уровень доступа). Однако можно сделать их видимыми для подклассов этих переменных с помощью модификаторов доступа.
• Переменные экземпляра имеют значения по умолчанию. Для чисел по умолчанию равно 0, для логических - false, для ссылок на объект - null. Значения могут быть присвоены при объявлении или в конструкторе.
• Переменные экземпляра в Java могут быть доступны непосредственно путем вызова имени переменной внутри класса. Однако в статических методах и различных класса (когда к переменным экземпляра дана доступность) должны быть вызваны используя полное имя - ObjectReference.VariableName .

Пример

import java.io.*; public class Employee{ // Переменная экземпляра открыта для любого дочернего класса. public String name; // Переменная salary видна только в Employee. private double salary; // Имя переменной присваивается в конструкторе. public Employee (String empName){ name = empName; } // Переменной salary присваивается значение. public void setSalary(double empSal){ salary = empSal; } // Этот метод выводит на экран данные сотрудников. public void printEmp(){ System.out.println("имя: " + name); System.out.println("зарплата:" + salary); } public static void main(String args){ Employee empOne = new Employee("Олег"); empOne.setSalary(1000); empOne.printEmp(); } }

Программа будет будет производить следующий результат:

Имя: Олег зарплата: 1000.0

Переменные класса или статические переменные в Java

• Переменные класса, также известные в Java как статические переменные , которые объявляются со статическим ключевым слово в классе, но за пределами метода, конструктора или блока.
• Там будет только одна копия каждой статической переменной в классе, независимо от того, сколько объектов создано из него.
• Статические переменные или переменные класса в Java используются редко, кроме когда объявляются как константы. Константы - переменные, которые объявлены как public/private, final и static. Константы никогда не меняются от первоначального значения.
• В Java статические переменные создаются при запуске программы и уничтожаются, когда выполнение программы остановится.
• Видимость похожа на переменную экземпляра. Однако большинство статических переменных объявляются как public, поскольку они должны быть доступны для пользователей класса.
• Значения по умолчанию такое же, как и у переменных экземпляра. Для чисел по умолчанию равно 0, для данных типа Boolean - false; и для ссылок на объект - null. Значения могут быть присвоены при объявлении или в конструкторе. Кроме того, они могут быть присвоены в специальных блоках статического инициализатора.
• Статические переменные могут быть доступны посредством вызова с именем класса ClassName.VariableName .
• При объявлении переменных класса как public, static, final, имена находятся в верхнем регистре. Если статические переменные такими не являются, синтаксис такой же, как у переменных экземпляра и локальных.

Пример

import java.io.*; public class Employee{ // salary(зарплата) переменная private static private static double salary; // DEPARTMENT(отдел) - это константа public static final String DEPARTMENT = "Разработка "; public static void main(String args){ salary = 1000; System.out.println(DEPARTMENT+"средняя зарплата: "+salary); } }

Это будет производить следующий результат:

Разработка средняя зарплата: 1000

Примечание: для получения доступа из внешнего класса, константы должны быть доступны как Employee.DEPARTMENT.

В предыдущих материалах не раз упоминались модификаторы доступа. В следующем уроке мы подробно их рассмотрим.