Java Core для самых маленьких. Часть 3. Переменные / Хабр
В предыдущей статье мы говорили о типах данных, а теперь поговорим о вытекающей из этого теме, о переменных.
Переменная — это поименованная область памяти, в которую мы можем сохранить данные, осуществлять доступ к этим данным или изменять их. Простыми словами, переменная в программировании, и в Java в том числе, является основной единицей хранения информации. В Java у переменной должен быть тип, имя и значение.
На скриншоте выше продемонстрирован пример создания переменных.
Тип — это тип данных переменной, которую необходимо создать. В примере используются примитивные типы данных, рассмотренные в предыдущей статье. Однако, переменная может быть не только примитивного типа. Переменная может являться экземпляром какого-либо класса. Изучать классы мы будем в следующих статьях.
Имя или Идентификатор — любую переменную нужно как-то обозвать. А даем мы имя переменной сразу после указания типа данных. Важно! Именем переменной может быть любая последовательность букв, цифр, но имя не может начинаться с цифры! При наименовании переменной так же учитывается регистр символов. abc и ABC будут разными именами. Еще можно встретить переменные, имя которых начинается с символа валюты доллара: $Например: double $pi = 3.14; Такое можно увидеть в авто-генерируемых участках кода. Живые люди, насколько мне известно, так не пишут.
Давайте сразу научимся давать имена переменным правильно. Существует документ Java Code Conventions. В нем указаны правила к написанию кода на Java. Нужно это для того, что бы Java код в разных проектах был написан в едином стиле. Таким образом, новоприбывший на проект программист не будет отвлекаться на новый стиль кода, ведь он будет оформлен так же, как и на других проектах.
Эти правила работают и при нейминге переменных.
Итак, переменные принято называть в lowerCamelCase стиле. Сейчас покажу как хорошо, а как плохо:
Как вы могли заметить, в примере, в имени переменной используется символ подчеркивания _ . На практике допускается использовать такой символ только для имен констант. Чем константа отличается от переменной? Переменная на то и переменная, что ее значение изменчиво и всегда можно присвоить другое:
Вот было значение 1998, а на следующей строке стало 2000. А вот с константой так не получится. Константа гарантирует, что ее значение не изменится на протяжении всего времени выполнения программы. Как создать константу? Очень просто:
Нужно всего лишь дописать ключевое слово final перед типом данных переменной. Для простоты понимания, мы как бы «финализируем» значение переменной и говорим, что это значение конечное.
Обратим внимание на имя константы.
Когда мы даем имя константе, то должны делать это в стиле SCREAMING_SNAKE_CASE. Давайте исправим мой код:
В целом, вас никогда не погладят по головке за правильный нейминг в коде. Подразумевается, что это нечто естественное при написании кода. Как правила этикета у людей. А вот если вы будете называть ваши переменные и константы абы как, получите незамедлительного леща.
Инициализация переменных
У всех переменных из моих примеров уже было присвоено начальное значение. Процесс присвоения начального значения называется инициализацией переменной. И не обязательно инициализировать переменную во время ее объявления. Java позволяет сделать это и позже.
Во-первых, можно объявлять переменные через запятую (если они одинакового типа):
При этом, смотрите, мы можем некоторые из них инициализировать прямо во время объявления. А теперь инициализируем оставшиеся:
Для инициализации переменных типа char я использовал цепочку присваиваний.
Да, и так тоже можно. Хотя используется очень редко.
Если мы попытаемся провести какую-то операция с переменной, у которой нет значения, то получим ошибку.
Оператор присваивания
Важно запомнить, что если вы где-то в коде Java, а также во многих других языках, увидите знак равенства =, вы должны понимать, что это не сравниваются два значения. Вы должны понимать что это оператор присваивания. Его задача: взять значение, которое стоит справа от него, и записать в память переменной, которая стоит слева от него, или другими словами присвоить. Важно, чтобы значения справа и слева были одного типа данных в противном случае получаем ошибку.
Литералы
Видели, в моих примерах выше, я писал значение переменной с типом long не просто 1998 а 1998L? Сейчас расскажу, что это за L в конце.
В Java постоянные значения задаются литеральным представлением.
Простым языком, при помощи определенных символов мы можем указывать тип данных. Вот например, при работе с целочисленными литералами нам не нужны никакие литералы. Мы просто пишем число 1998; и Java понимает, что это целочисленное значение.
Целочисленные литералы по умолчанию создаются в виде значения типа int, и это значение можно присваивать всем целочисленным типам данных без проблем, в случае, если это значение не выходит за пределы допустимых значений (в предыдущей статье мы говорили о диапазонах значений у разных типов данных). Но что делать, если мы хотим указать целое число, которое больше пределов числа типа int? В этом случае есть возможность создать литерал типа long просто указав в конце символ L. Я мог и не писать 1998L, потому что число 1998 вполне помещается в диапазон значений типа данных int.
А теперь, я вдруг захотел присвоить переменной типа long значение, скажем, в девять миллиардов. Число не маленькое и оно выходит за пределы максимального значения типа int.
Вот тут нам понадобится литерал типа long. При помощи символа L, в конце целочисленного значения, мы явно указывается, что это значение будет типа long, а следовательно и с большим диапазоном значений.
Так, что еще за символы подчеркивания в значении переменной? Это всего-навсего декор. С JDK 7 допустимо указывать знаки подчеркивания, для разбиения больших чисел на разряды, для удобства чтения.
В вышеописанных примерах были литералы для целочисленных десятичных значений. А еще мы можем присвоить целому числу литерал в виде восьмеричного значения. Для этого вам нужно добавить в самом начале значения 0. Но в таком случае, логично, что это значение не сможет содержать цифры 8 и 9, поскольку они выходят за пределы восьмеричной системы счисления.
Мало того, еще мы можем использовать литерал шестнадцатеричных значений. Такие значения обозначают с начальным 0x или 0X, а цифры в пределах от 10 до 15 заменяются символами ABCDEF английского алфавита.
С JDK 7 есть возможность указывать целочисленные литералы в двоичном виде. Для этого вначале значения нужно указать 0b или 0B и соответственно в значениях можно использовать только цифры 0 и 1. В реальности, вам навряд ли понадобятся литералы шестнадцатеричных, восьмеричного или двоичных значений. Однако, знать о них нужно.
Литералы дробных чисел
Литералы дробных чисел могут быть представлены в привычном для нас виде. Они состоят из целой и дробной части, которые разделены точкой. Например: 10.9;.
Но существует и экспоненциальная форма записи этих чисел в виде 2.
34e12;
Где число после символа ‘e’ обозначает степень 10-ти. Простыми словами, мы записали 2 целых и 34 сотых умноженное на 10 в 12 степени.
По умолчанию литералы дробных чисел имеют тип double, если хотим создать литерал типа float, нужно указать символ f или F в конце значения. Как я уже сказал, по умолчанию, литерал будет типа double, однако мы все же можем указать это явно, дописав в конце значения символ d или D. Особого смысла это иметь, конечно же, не будет.
Как и в случае с целочисленными значениями, литералы с плавающей точкой поддерживают нижнее подчеркивание начиная с JDK 7.
Логические литералы
С логическими литералами все просто, они поддерживают только два логических значения true или false.
Символьные литералы
Для символьных литералов, которые присутствуют на вашей клавиатуре вы можете использовать одинарные кавычки, обернув ими необходимый вам символ введенный с клавиатуры.
Я не просто так обратил ваше внимание на символы с клавиатуры. Ведь существуют и такие символы, которых на клавиатуре нет, да и на символы они не похожи. Сейчас разберемся.
Как я уже говорил, тип char целочисленный и может хранить в себе символы кодировки Unicode. Unicode — это стандарт кодировки символов, который присваивает каждому символу код, в виде положительного целочисленного значения. Поэтому, тип char не может хранить отрицательные значения. А также, над типом char можно выполнять операции сложения и вычитания. Не представляю, зачем кому-то может понадобиться выполнять арифметические операции над типом char, но знайте, Java это позволяет. Мало того, коды символов английского алфавита (и многих других), расположены в порядке возрастания. Например, символу a соответсвует код 97, символу b — код 98. На основе этого можно сортировать символы по алфавиту.
А вот если символ нельзя ввести непосредственно с клавиатуры, то для ввода таких символов используют ряд управляющих последовательностей. Например, символ переноса строки ‘\n’. Существуют последовательности, которые существуют для ввода значений в восьмеричной и шестнадцатеричной форме. Например, мы захотели ввести букву tu катаканы смайлик: ツ. Берем и пишем:
В данной таблице вы можете посмотреть наиболее используемые последовательности символов:
Когда-то давно, я писал статью про экранирование символом. Настоятельно рекомендую прочитать, как дополнительный материал. Узнаете много интересного.
Строковый литерал
Можно заключить последовательность символов в двойные кавычки и получить так называемую строку.
Про строки будет отдельная статья, через одну если быть точным. Там нам будет о чем поговорить, а пока просто имейте ввиду что "" — это строковый литерал.
Динамическая инициализация
Пару слов о таком термине как динамическая инициализация.
Ничего сложного, только звучит страшно.
Переменную можно инициализировать другой переменной. Также, допускается инициализация переменной результатом какого-то выражения.
Главное, чтобы тип данных выражения / инициализирующей переменной совпадал с типом данных целевой переменной.
Преобразование и приведение типов
Знаю, вы уже подустали, сделали массу перерывов и подходов. Обещаю, это последняя тема в этой статье.
Часто программисты сталкиваются с ситуацией, когда переменной одного типа приходится присваивать значение другого типа. Если оба типа данных совместимы, их преобразование будет выполнено автоматически. Для автоматического преобразования должно выполняться 2 условия:
Не так страшен черт, как его малюют. Все очень просто. Например, тип long достаточно велик чтобы поместить в себя тип int и прочие целочисленные типы данных которые меньше long.
На картинке выше, вы можете увидеть, какие типы данных вы можете преобразовать автоматически.
Исходя из этого изображения, мы можем в переменную типа float поместить значение типа long. Звучит странно, давайте проверим:
Все работает. К сожалению, автоматическое преобразование не способно покрыть все потребности. Например если нужно тип int преобразовать в byte.
Чтобы выполнить преобразование двух несовместимых типов данных, нужно воспользоваться приведением типов. Это явное преобразование одного типа в другой. И выглядит это вот так:
Нужно понимать, что преобразование вы проводите на свой страх и риск. Вы должны быть уверенным в том, что преобразуемое значение помещается в диапазон целевого типа. В противном случае вы получите некорректные данные.
Подводим итоги
В этой статье мы поговорили о многих важных вещах. Узнали, как создавать переменные и константы в Java, и чем они отличаются. Узнали о способах инициализации переменных.
Разобрались с тем, что такое литералы и какие они бывают. А так же выполнили преобразование и приведение типов данных.
Скажем спасибо Егору за предоставленный материал.
В следующей статье мы будем изучать массивы. Если переменная — это вагон, то поездом будет массив. В общем, будет опять многобукав и многомерные массивы. Всем спасибо за внимание. Учитесь старательно!
Переменные в Java
В этом уроке мы познакомим с основами синтаксиса Java вместе с полезными концепциями для понимания некоторых важных аспектов выполнения программы.
Многие из частей, вероятно, уже вам известны, если вы когда-либо использовали какой-либо язык программирования.
Содержание
- Переменные, идентификаторы и адреса
- Объявить переменные
- Имена переменных
- Типы переменных
- Локальные переменные
- Переменные экземпляра
- Переменные класса (статические)
- Часто задаваемые вопросы
Переменные, идентификаторы и адреса
Формально мы могли бы определить переменную на языке программирования как пару, состоящую из:
- имя (также называемый идентификатором)
- и адрес памяти, предназначенный для хранения определенной величины, обычно называемой значением переменной.
Символьное имя переменной используется в программах для ссылки на адрес памяти, чтобы получить доступ и / или изменить его значение во время выполнения.
Объявить переменные
В Java (который принадлежит к классу типизированных языков) каждая переменная также имеет связанный с ним тип (например Integer, String, boolean и т.д.), что определяет характеристики, которые имеют значения, что переменная может взять на себя.
Например, переменная типа Integer может содержать значение, 40 но не текст "сорок".
В общем, в Java тип переменной может быть одним из предопределенных (примитивных) типов языка или типом, определенным нами, как мы увидим в следующих разделах.
Синтаксис объявления переменной в Java следующий:
[public|protected|private] [static] [final]тип_данныхидентификатор(имя_переменной)][=значение];
где части в квадратных скобках «[]» являются необязательными, а символ вертикальной черты «|» следует читать как «или» (значение ключевых слов будет разъяснено ниже).
Мы также можем инициализировать переменную, когда присутствует символ «=«, за которым следует значение, которое он должен принять.
Имена переменных
Синтаксически идентификатор (имя) переменной представляет собой последовательность букв и цифр, первым элементом которой должна быть буква, символ подчеркивания (‘_‘) или символ доллара (‘$‘).
В любом случае, конвенция (не синтаксическое правило) находится в силе, что имена переменных начинаются с буквы нижнего регистра и, если формируется несколькими словами, связанных между собой, все слова кроме первого начинаются с верхнего регистра, а не используют символ “_”, $хотя он разрешен. Например:
int wordCount;Идентификатор может быть любой строкой, но в языке есть зарезервированные слова, которые нельзя использовать в качестве идентификаторов:
abstract | continue | for | new | switch |
assert | default | goto | package | synchronized |
boolean | do | if | private | this |
break | double | implements | protected | throw |
byte | else | import | public | throws |
case | enum | instanceof | return | transient |
catch | extends | int | short | try |
char | final | interface | static | void |
class | finally | long | strictfp | volatile |
const | float | native | super | while |
Типы переменных
В Java есть три типа переменных: локальные переменные, переменные экземпляра и переменные класса.
Посмотрим подробно, что это такое.
Локальные переменные
Мы говорим о локальных переменных, когда объявление происходит внутри метода.
Локальные переменные создаются при вызове метода и исчезают (стираются из памяти) при выходе из метода.
Каждая переменная, объявленная в методе, может использоваться только внутри самого метода, а в Java локальные переменные не могут использоваться до их инициализации.
Например, если мы попытались скомпилировать следующий метод:
void add(long i) {
long j;
j = j + i;
}компилятор Java выдал бы нам сообщение об ошибке, потому что переменная j не была инициализирована перед ее использованием, и поэтому невозможно добавить значение к переменной, пока ей не будет присвоено значение.
Вместо этого следующий код будет компилироваться без ошибок:
void add(long i) {
long j = 1;
j = j + i;
}
При выполнении этого фрагмента кода виртуальная машина Java создает пространство в памяти для записи локальных переменных, I и j затем удаляет их (освобождая пространство памяти) в конце выполнения метода add.
Переменные экземпляра
Переменные экземпляра, также известные как поля, объявляются внутри класса, но вне любого метода.
Поля имеют в качестве своей области все тело класса, в котором они объявлены, включая методы самого класса. Таким образом, они видны во всех методах класса.
Может случиться так, что локальная переменная в методе (или параметр метода) имеет то же имя (идентификатор), что и переменная экземпляра.
Посмотрим на пример:
public class Scope {
int var = 6;
public void metod1(int var) {
int i = var;
// в этом случае параметр var имеет приоритет
// принимая значение, которое будет передано в качестве параметра методу
}
public void metod2() {
int var = 7;
int i = var;
//здесь локальная переменная имеет приоритет над методом, поэтому
// i имеет значение 7
}
public void metod3() {
int i = var;
// здесь мы просто присваиваем i значение
// переменной экземпляра и i принимает значение 6
}
public void metod4(int var) {
int i = this.var;
// в этом случае i принимает значение 6
// из значения параметра, поскольку мы использовали
// ключевое слово 'this' указывает на использование переменной 'var'
// которое мы определили, как поле и которое принадлежит
// текущему экземпляру класса.
}
}
Экземпляр переменной (нестатический) продолжает существовать в памяти программы до тех пор, пока существует объект, который его содержит (объект «остается живым», пока существует хотя бы одна ссылка).
Переменные класса (статические)
Переменные класса, также обычно называемые статическими полями, являются переменными экземпляра, но в их определении используется ключевое слово ‘static’.
static int var = 6;
Переменная класса — это переменная, видимая из всех экземпляров этого объекта, и ее значение не меняется от экземпляра к экземпляру, поэтому оно принадлежит всему классу.
Более подробно, в то время как для переменных экземпляра новая ячейка памяти выделяется для каждого экземпляра класса, для статических переменных существует одна ячейка памяти, связанная с классом и не связанная с каждым отдельным экземпляром.
Статическая переменная класса живет (то есть сохраняет занятость памяти и продолжает сохранять свое значение) до конца программы.
Часто задаваемые вопросы
Как Java CodeConvention рекомендует называть классы и методы?
Инициализированная переменная в Java имеет?
Для объявления переменной в Java достаточно задать:
Что такое значение переменной?
Документация JDK 19 — Главная
- Главная
- Ява
- Java SE
- 19
Обзор
- Прочтите меня
- Примечания к выпуску
- Что нового
- Руководство по миграции
- Загрузить JDK
- Руководство по установке
- Формат строки версии
Инструменты
- Технические характеристики инструментов JDK
- Руководство пользователя JShell
- Руководство по JavaDoc
- Руководство пользователя средства упаковки
Язык и библиотеки
- Обновления языка
- Основные библиотеки
- HTTP-клиент JDK
- Учебники по Java
- Модульный JDK
- Руководство программиста API бортового регистратора
- Руководство по интернационализации
Технические характеристики
- Документация API
- Язык и ВМ
- Имена стандартных алгоритмов безопасности Java
- банок
- Собственный интерфейс Java (JNI)
- Инструментальный интерфейс JVM (JVM TI)
- Сериализация
- Проводной протокол отладки Java (JDWP)
- Спецификация комментариев к документации для стандартного доклета
- Прочие характеристики
Безопасность
- Руководство по безопасному кодированию
- Руководство по безопасности
Виртуальная машина HotSpot
- Руководство по виртуальной машине Java
- Настройка сборки мусора
Управление и устранение неполадок
- Руководство по устранению неполадок
- Руководство по мониторингу и управлению
- Руководство по JMX
Client Technologies
- Руководство по специальным возможностям Java
Переменные Java
Переменные Переменная int cansPerPack = 6; Переменные используются в программах, чтобы значения могли быть представлены осмысленными именами. Например, когда в программе используется переменная с именем length, ясно, что ее значением является расстояние. Переменные следует использовать для представления значений, поскольку они упрощают чтение, понимание и модификацию кода. Каждая переменная имеет имя и содержит значение. Вы можете думать о переменной как о почтовом ящике. Почтовый ящик имеет адрес и может содержать письма. Переменная похожа тем, что имеет имя (например, адрес почтового ящика) и может содержать значения (письма в почтовом ящике). Объявление переменных Переменная должна быть объявлена перед использованием . <Тип данных> <имя> Объявление включает в себя две части:
Например, в декларации int length; int — тип данных, длина — идентификатор. int хранит целочисленное значение, которое является положительным или отрицательным целым числом. Когда объявляется целочисленная переменная, она сохраняет значение 0,9.0125 Инициализация переменной A При объявлении переменной вы обычно ее инициализируете. int cansPerPack = 6; Переменная cansPerPack инициализируется значением 6. Правила именования переменныхКогда вы объявляете переменную, вы должны выбрать имя, которое объясняет ее назначение. Например, лучше использовать описательное имя, такое как ширина , чем сокращение, такое как w . Java действительно не волнует, используете ли вы длину или w , но другие программисты, которые читают ваш код, будут. Они должны будут угадать, было ли w значит . В Java есть несколько простых правил для имен переменных:
|
Следующий оператор объявляет переменную с именем cansPerPack :
Объявление принимает форму:
Это означает, что вы устанавливаете значение, которое должно храниться в переменной. Рассмотрим снова это объявление переменной: