Как сделать константу в java

Обновлено: 08.07.2024

Мы уже и использовали переменные в наших примерах, поскольку без них было бы очень затруднительно объяснить примитивные типы данных в Java, но не акцентировали на этом внимания, так как это не большая и не сложная тема. О константах в Java мы вообще пока не говорили. И вот настало время! Ну погнали!

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

В Java все переменные должны быть объявлены до их использования. Объявить переменную можно в любом месте программы. Основная форма объявления переменных выглядит следующим образом:

тип идентификатор [=значение][, идентификатор [=значение] . ] ;

тип — это один из элементарных типов Java либо имя класса или интерфейса.
идентификатор — это имя переменной

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

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

int a , b , c ; // объявление трех переменных типа int: a, b и c
int d = 3 , e , f = 5 ; // объявление еще трех переменных типа int с инициализацией d и f
byte z = 22 ; // инициализация переменной z
double pi = 3.14159 ; // объявление приблизительного значения переменной pi
char x = 'x' ; // присваивание значения 'x' переменной x

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

int vacationDays ;
System . out . println ( vacationDays ) ; // ОШИБКА! Переменная не инициализирована

Динамическая инициализация переменных

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

double a = 3.0 , b = 4.0 ;
// динамическая инициализация переменной c
double c = Math . sqrt ( a * a + b * b ) ;
System . out . println ( "Гипотенуза равна " + c ) ;

Область действия и время существования переменных

Это достаточно важный вопрос и его надо рассмотреть поподробнее. И для этого сперва надо рассмотреть использование блоков кода в Java.

Использование блоков кода

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

if ( x ) < // начало блока
x = y;
y = 0 ;
> // конец блока

В этом примере, если x меньше y, программа выполнит оба оператора, расположенные внутри блока. Таким образом, оба оператора внутри блока образуют логический модуль, и выполнение одного оператора невозможно без одновременного выполнения и второго. Основная идея этого подхода состоит в том, что во всех случаях, когда требуется логически связать два или более оператора, это делается посредством создания блока.

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

Основное правило, которое следует запомнить: переменные, объявленные внутри области действия, не видны (т.е. недоступны) коду, который находится за пределами этой области. Таким образом, объявление переменной внутри области действия ведет к ее локализации и защите от несанкционированного доступа и/или изменений.

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

Переменная y, определенная внутри своей области действия ограниченной фигурными скобками, доступна только в ней. За ее пределами переменная y уже не доступна, а переменная x доступна, и во области действия переменной y.

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

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

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

Код приведенный на примере слева, выдаст ошибку компиляции.

Такие трюки возможные в C и C++ в Java не проходят.

Константы в Java

В Java для обозначения констант служит ключевое слово final. Ключевое слово final означает, что присвоить данной переменной какое-нибудь значение можно лишь один раз, после чего изменить его уже нельзя. Рекомендуется использовать для именования констант прописные буквы, хоть это и не является обязательным, но такой стиль способствует удобочитаемости кода. Пример объявления константы:

final double CM_PER_INCH = 2.54 ;

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

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

enum Тип Java 5 и выше

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

final означает, что значение не может быть изменено после инициализации, что делает его постоянным. static означает, что вместо выделения места для поля в каждом объекте, для класса создается только один экземпляр.

Таким образом, это static final означает только один экземпляр переменной, независимо от того, сколько объектов создано, и значение этой переменной никогда не может измениться.

-1. Предупреждение: A final int нельзя использовать в switch операторе, поэтому я полагаю, что a final int не является константой времени компиляции.

Все, что есть static на уровне класса. Вам не нужно создавать экземпляр для доступа к статическим полям / методу. Статическая переменная будет создана один раз при загрузке класса.

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

В вашем случае, когда вы объявили его как static final , это только одна копия переменной. Если вы измените его из нескольких экземпляров, одна и та же переменная будет обновлена (однако у вас есть final переменная, поэтому ее нельзя обновить).

Во втором случае также final int a является константой, однако она создается каждый раз, когда вы создаете экземпляр класса, в котором объявлена эта переменная.

Представьте себе задачу, нам нужно напечатать на экран фразу Father! два раза или даже пять раз. Эту задачу можно решить в лоб:

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

В строчке var greeting = "Father!" - происходит присваивание значения "Father!" переменной с именем greeting .

Когда переменная создана, можно начать её использовать. Она подставляется в те места, где раньше стояла наша фраза. Во время выполнения кода, в строке System.out.println(greeting) вместо переменной подставляется её содержимое, а затем выполняется код. В результате вывод нашей программы будет таким:

Для имени переменной используется любой набор допустимых символов, к которым относятся буквы английского алфавита, цифры, знаки - и _ . При этом цифру нельзя ставить в начале. Имена переменных регистрозависимы, то есть имя hello и имя heLLo - это два разных имени, а значит и две переменные. Ниже пример с двумя разными переменными:

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

Изменение переменной

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

Интересно то, что компилятор делает такую проверку без запуска кода на выполнение, именно поэтому такой вид типизации называют статическим (статика – без запуска). В динамических языках, таких как Javascript, Ruby, PHP или Python, подобное поведение не является ошибкой, переменная может легко изменить свой тип в процессе работы.

Ошибки при работе с переменными

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

Запуск программы выше завершается с ошибкой:

Ошибка cannot find symbol означает, что в коде используется переменная, которая не определена. Причем в самой ошибке об этом говорят прямо: variable greeting . Кроме неправильного порядка определения, в Java встречаются банальные опечатки, причем как при использовании переменной, так и при ее объявлении.

Еще одна распространенная ошибка — попытаться объявить уже объявленную переменную:

Так делать нельзя. Придётся создать новую переменную.

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

Выражения в определениях

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

Для начала переведем 50 евро в доллары. Допустим, что один евро — 1.25 доллара:

В предыдущем блоке мы записывали в переменную конкретное значение. А здесь var dollarsCount = 50 * 1.25; справа от знака равно находится выражение. Программа вычислит результат — 62.5 — и запишет его в переменную. С точки зрения программы не важно, что написано: 62.5 или 50 * 1.25, эти оба варианта — выражения, которые надо вычислить. И они вычисляются в одно и тоже значение — 62.5. Любая строка — выражение. Конкатенация строк — тоже выражение. Когда программа видит выражение, она вычисляет его и возвращает результат. Вот несколько примеров выражений, а в комментариях справа от каждого выражения — итоговое значение:

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

Вернемся к нашей валютной программе. Запишем стоимость доллара в рублях, как отдельную переменную. Вычислим цену 50 евро в долларах, умножив их на 1.25. Допустим, что 1 доллар — 60 рублей:

А теперь давайте добавим к выводу текст с помощью конкатенации:

Переменные и конкатенация

Переменные и конкатенацию можно объединять. Синтаксически ничего не меняется: мы умеем конкатенировать (склеивать) две строки:

… а значит сумеем конкатенировать строку и одну переменную, в которой записана строка:

… и даже конкатенировать две переменные, в которых записаны строки:

Константы

Некоторые данные, такие как математические постоянные, никогда не меняются. Возьмем число π. Приближенно оно всегда равно 3.14 и не может измениться.

Для обращения к подобным данным в Java принято использовать константы.

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

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

Вам ответят команда поддержки Хекслета или другие студенты.

Нашли опечатку или неточность?

Выделите текст, нажмите ctrl + enter и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.

Что-то не получается или материал кажется сложным?

задайте вопрос. Вы быстрее справитесь с трудностями и прокачаете навык постановки правильных вопросов, что пригодится и в учёбе, и в работе программистом;
расскажите о своих впечатлениях. Если курс слишком сложный, подробный отзыв поможет нам сделать его лучше;
изучите вопросы других учеников и ответы на них. Это база знаний, которой можно и нужно пользоваться.

Об обучении на Хекслете

Открыть доступ

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

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

Далее, второй строчкой идет определение класса. О классах мы еще подробно поговорим. Пока просто запомните, что класс задается с помощью ключевого слова class и далее идет имя этого класса – в данном случае Main. Внутри фигурных скобок мы прописываем данные класса – это его переменные и методы – это его функции. А вот это ключевое слово public означает, что класс доступен везде и всем. Это, в частности, необходимо, чтобы виртуальная машина имела к нему доступ и могла выполнить его, т.е. запустить нашу программу.

Внутри класса интегрированная среда нам автоматически прописала вот такой метод:

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

Внутри фигурных скобок располагаются инструкции языка Java: его операторы, функции и т.д. Например, у нас записана такая инструкция:

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

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

Переменные и константы

хранят данные;
выполняют арифметические операции;
выполняют логические операции;
реализуют циклы.

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

Для создания переменных в Java используется такой синтаксис:

для целочисленных чисел в диапазоне:

от -32768 до 32767

для целочисленных чисел в диапазоне:

от - 2147483648 до 2147483647

для целочисленных чисел в диапазоне:

от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807

для вещественных чисел в диапазоне:

для одиночного символа в кодировке UTF-16

занимает 2 байта

программа должна расходовать как можно меньше памяти;
программа должна работать как можно быстрее и быть надежной.

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

имена лучше задавать латиницей, даже если есть возможность писать кириллицу;
в качестве первого символа можно использовать символы a-z, A-Z и символ _
в качестве второго и последующих символов можно писать еще и цифры 0-9.

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

Например, мы можем определить переменные вот так:

В первой строчке создается целочисленное хранилище с именем a. Во второй строчке создается тоже целочисленное хранилище с именем b и в него сразу записывается значение 5. Это называется начальной инициализацией переменной в момент ее объявления.

Теперь обратите внимание на имена переменных a и A – это две разные переменные, т.е. Java различает регистр букв. Далее, можно объявить через запятую сразу несколько переменных. Ну и наконец, при объявлении нескольких переменных, мы также можем сразу выполнять их инициализацию.

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

то интегрированная среда предупредит нас об ошибке. Почему? Здесь вроде бы все верно? Дело в том, что любое числовое вещественное значение в Java представляется типом double и потому мы в этой строчке пытаемся значение типа double присвоить переменной типа float. В результате может произойти потеря информации и именно об этом и сообщает интегрированная среда. Чтобы все-таки присвоить 3,5 переменной float следует указать значение 3,5 как тип float:

Символьные типы данных можно задавать и инициализировать вот таким образом:

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

Переменные в Java можно создавать в любом месте класса или функции по мере необходимости.

Если требуется вывести в консоль значение какой-либо переменной, то используется такая инструкция:

Однако, если мы напишем следующую строчку вот такую:

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

Наконец, константы в языке Java, задаются так:

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

то интегрированная среда нам сообщит об ошибке, что так делать нельзя, т.к. PI – это константа.

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

Ну и наконец, как в Java можно присваивать значения переменным после их объявления? Для этого в Java используется оператор присваивания. Он записывается как знак равно (=). Само присваивание значение переменной выглядит, например, так:

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

Здесь справа текущее значение i сначала увеличивается на 1, становится равным 2, и после этого результат присваивается снова этой же переменной. В результате переменная увеличивает свое значение на 1. Видите разницу между математическим знаком равенства и оператором присваивания? С математической точки зрения такое равенство выполняться не может, но с точки зрения оператора присваивания никаких проблем!

Также не имеет смысла запись вида

так как константе 20 нельзя присвоить какое-либо значение.

Наконец, рассмотрим два таких примера:

Здесь присвоение a=b работает без каких-либо замечаний, но вот на b=a интегрированная среда ругается и говорит, что возможна потеря данных, т.к. тип short меньше типа int. Чтобы все-таки такое присвоение стало возможным, нужно сделать приведение типа переменной a к типу short в момент присваивания, то есть, записать это в таком виде:

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

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

Вот так работает оператор присваивания и вот так присваиваются значения переменным в Java.

На этом мы завершим наше занятие. Из него вы должны себе представлять в целом начальную структуру программы на Java и знать как объявлять переменные и константы и как работает оператор присваивания.

Видео по теме

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

Читайте также: