Как сделать переменную видимой во всех классах java
Переменная предоставляется нам именем хранения, чтобы нашей программой можно было манипулировать. Каждая переменная в Java имеет конкретный тип, который определяет размер и размещение её в памяти; диапазон значений, которые могут храниться в памяти; и набор операций, которые могут быть применены к переменной.
Необходимо объявить все переменные, прежде чем их использовать. Ниже показана основная форма объявления:
Чтобы объявить более чем одну переменную указанного типа, можно использовать список с запятыми в качестве разделителей.
Ниже приведены примеры объявления переменной и инициализации в Java:
В этом уроке рассмотрим различные типы переменных, доступных в языке Java. Существует три типа переменных:
- локальные переменные;
- переменные экземпляра;
- статические переменные или переменные класса.
Содержание
Локальные переменные в Java
- Локальные переменные объявляются в методах, конструкторах или блоках.
- Локальные переменные создаются, когда метод, конструктор или блок запускается и уничтожаются после того, как завершиться метод, конструктор или блок.
- Модификаторы доступа нельзя использовать для локальных переменных.
- Они являются видимыми только в пределах объявленного метода, конструктора или блока.
- Локальные переменные реализуются на уровне стека внутри.
- В Java не существует для локальных переменных значения по умолчанию, так что они должны быть объявлены и начальное значение должны быть присвоено перед первым использованием.
Пример
Будет получен следующий результат:
Пример без инициализации
Переменные экземпляра
Пример
Программа будет будет производить следующий результат:
Переменные класса или статические переменные в Java
- Переменные класса, также известные в Java как статические переменные, которые объявляются со статическим ключевым слово в классе, но за пределами метода, конструктора или блока.
- Там будет только одна копия каждой статической переменной в классе, независимо от того, сколько объектов создано из него.
- Статические переменные или переменные класса в Java используются редко, кроме когда объявляются как константы. Константы - переменные, которые объявлены как public/private, final и static. Константы никогда не меняются от первоначального значения.
- В Java статические переменные создаются при запуске программы и уничтожаются, когда выполнение программы остановится.
- Видимость похожа на переменную экземпляра. Однако большинство статических переменных объявляются как public, поскольку они должны быть доступны для пользователей класса.
- Значения по умолчанию такое же, как и у переменных экземпляра. Для чисел по умолчанию равно 0, для данных типа Boolean — false; и для ссылок на объект — null. Значения могут быть присвоены при объявлении или в конструкторе. Кроме того, они могут быть присвоены в специальных блоках статического инициализатора.
- Статические переменные могут быть доступны посредством вызова с именем класса ClassName.VariableName.
- При объявлении переменных класса как public, static, final, имена находятся в верхнем регистре. Если статические переменные такими не являются, синтаксис такой же, как у переменных экземпляра и локальных.
Пример
Это будет производить следующий результат:
Примечание: для получения доступа из внешнего класса, константы должны быть доступны как Employee.DEPARTMENT.
В предыдущих материалах не раз упоминались модификаторы доступа. В следующем уроке мы подробно их рассмотрим.
В этом уроке мы познакомим с основами синтаксиса Java вместе с полезными концепциями для понимания некоторых важных аспектов выполнения программы.
Многие из частей, вероятно, уже вам известны, если вы когда-либо использовали какой-либо язык программирования.
Переменные, идентификаторы и адреса
Формально мы могли бы определить переменную на языке программирования как пару, состоящую из:
- имя (также называемый идентификатором)
- и адрес памяти, предназначенный для хранения определенной величины, обычно называемой значением переменной.
Символьное имя переменной используется в программах для ссылки на адрес памяти, чтобы получить доступ и / или изменить его значение во время выполнения.
Объявить переменные
В Java (который принадлежит к классу типизированных языков) каждая переменная также имеет связанный с ним тип (например Integer , String , boolean и т.д.), что определяет характеристики, которые имеют значения, что переменная может взять на себя.
Например, переменная типа Integer может содержать значение, 40 но не текст "сорок" .
В общем, в Java тип переменной может быть одним из предопределенных (примитивных) типов языка или типом, определенным нами, как мы увидим в следующих разделах.
Синтаксис объявления переменной в Java следующий:
Мы также можем инициализировать переменную, когда присутствует символ « = «, за которым следует значение, которое он должен принять.
Имена переменных
Синтаксически идентификатор (имя) переменной представляет собой последовательность букв и цифр, первым элементом которой должна быть буква, символ подчеркивания (‘ _ ‘) или символ доллара (‘ $ ‘).
В любом случае, конвенция (не синтаксическое правило) находится в силе, что имена переменных начинаются с буквы нижнего регистра и, если формируется несколькими словами, связанных между собой, все слова кроме первого начинаются с верхнего регистра, а не используют символ “ _ ”, $ хотя он разрешен. Например:
Идентификатор может быть любой строкой, но в языке есть зарезервированные слова, которые нельзя использовать в качестве идентификаторов:
| 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 локальные переменные не могут использоваться до их инициализации.
Например, если мы попытались скомпилировать следующий метод:
Вместо этого следующий код будет компилироваться без ошибок:
При выполнении этого фрагмента кода виртуальная машина Java создает пространство в памяти для записи локальных переменных, I и j затем удаляет их (освобождая пространство памяти) в конце выполнения метода add .
Переменные экземпляра
Переменные экземпляра, также известные как поля, объявляются внутри класса, но вне любого метода.
Поля имеют в качестве своей области все тело класса, в котором они объявлены, включая методы самого класса. Таким образом, они видны во всех методах класса.
Может случиться так, что локальная переменная в методе (или параметр метода) имеет то же имя (идентификатор), что и переменная экземпляра. В этом случае более конкретная переменная, то есть локальная переменная или параметр, имеет приоритет.
Посмотрим на пример:
Переменные класса (статические)
Переменные класса, также обычно называемые статическими полями, являются переменными экземпляра, но в их определении используется ключевое слово ‘static’.
Переменная класса — это переменная, видимая из всех экземпляров этого объекта, и ее значение не меняется от экземпляра к экземпляру, поэтому оно принадлежит всему классу.
Более подробно, в то время как для переменных экземпляра новая ячейка памяти выделяется для каждого экземпляра класса, для статических переменных существует одна ячейка памяти, связанная с классом и не связанная с каждым отдельным экземпляром.
Статическая переменная класса живет (то есть сохраняет занятость памяти и продолжает сохранять свое значение) до конца программы.
Переменная – это имя для области памяти, в которой хранится информация. Переменные в Java имеют свой тип. При объявлении переменной необходимо указать ее тип и дать ей имя. Имя переменной должно начинаться с буквы и представлять собой сочетание букв и цифр. Термины буквы и цифры имеют в Java более широкое значение, чем в других языках программирования. Буквами считаются символы A — Z , a — z, _ и любой другой символ в кодировке уникода, но обо всем по порядку. Рассмотрим небольшой пример, следующий код объявляет переменную num с типом int:
Обратите внимание на точку с запятой в конце объявления. Она необходима, потому что объявление в Java считается полным оператором. После того как мы объявили переменную, мы можем присвоить ей значение, это называется инициализация. Для того, чтобы присвоить переменной значение надо после имени переменной поставить знак равенства и указать присваиваемое значение:
В примере выше переменной num был присвоен 0. Совершенно не обязательно присваивать значение переменной при объявлении, это можно сделать позже:
Во всех примерах выше в качестве начальных значений переменных использовались константы, но Java допускает и динамическую инициализацю с помощью любого выражения:
В примере, две переменных a и b инициализируются константами 1 и 2 соответственно, когда как переменная c инициализируется динамически – суммой переменных a и b.
Объявление нескольких переменных.
Java позволяет объявлять и инициализировать несколько переменных сразу:
Мы объявили две переменных – num1 и num2, и присвоили им значения 1 и 2 соответственно. вы можете объявлять столько переменных в одном выражении сколько захотите, до тех пор, пока они остаются переменными одного типа, например, следующий код не скомпилируется:
Переменные num1 и num2 разных типов, что и вызывает ошибку компиляции. Даже если переменные одного типа, дважды указывать тип переменных в одном выражении не допускается, следующий код так же не скомпилируется:
Не смотря, на то, что обе переменные имеют одинаковый тип, второй раз тип int указывать не нужно.
Методы isJavaIdentifierStart() и isJavaIdentifierPart() из класса Character помогают определить какие символы можно считать “буквами” в Java
Хотелось бы отметить еще один очень важный момент, касающийся инициализации переменных. Рассмотрим следующий код:
В этом примере объявляются три переменных num1, num2 и num3, но только num3 присваивается значение 3.
Идентификаторы.
Java предъявляет строгие требования к именованию идентификаторов. К счастью те же самые требования применимы и к именованию методов, полей, классов. Имя переменной должно представлять собой сочетание букв и цифр. Длина имени переменной не ограничивается. Существует три основных правила именования переменных:
1. Имя должно начинаться с буквы или символов $ или _
2. Символы кроме первого могут быть цифрами
3. Имя идентификатора не должно совпадать с зарезервированным словом. Учтите Java учитывает регистр при обозначении имен, вы можете использовать зарезервированные слова для идентификаторов только в другом регистре, но делать это без очень веских на то оснований не стоит.
Класс Character обладает двумя методами isJavaIdentifierStart() и isJavaIdentifierPart(), которые позволяют узнать какие именно символы уникода можно считать буквами в Java. Ниже представлен список всех зарезервированных в Java слов. const и goto на данный момент в Java не используются, но остаются зарезервированными.
Литералы: true, false и null не являются зарезервированными словами, но также не могут быть использованы в качестве идентификаторов.
Исходя из выше изложенного вы вольны давать имена своим идентификатором, так как Вам захочется, соблюдая три простых правила, но увлекаться не стоит. Например, следующий код абсолютно корректен и компилируется без ошибок:
В этой статье мы рассмотрим, что такое Java-переменные, что значит инициализация переменных, а также как объявлять константу и зачем вообще нужны переменные и константы в Java.
Переменная — это контейнер, содержащий какое-либо значение. При этом под переменным значением понимают строковое, числовое или логическое значение. Само определение говорит нам о том, что переменная может изменяться по ходу выполнения программы. А вот если у нас задана константа, то это значение меняться не может. Но давайте обо всём по порядку.
Виды переменных в Java
Существуют следующие типы переменных в Java: 1) примитивные (целые — byte, short, char, int, long; дробные или с плавающей точкой — float, double, логические — boolean); 2) ссылочные (создаются с применением конструкторов классов и нужны для доступа к объектам).
Так как Java является строго типизированным языком программирования, каждая переменная, объявляемая разработчиком, должна иметь связанный с переменным значением тип данных.
Как объявлять переменные в Java?
Перед использованием переменной нужно её объявить. Для объявления переменной в Java используют следующий синтаксис:
Идём дальше: если нужно объявить больше чем одну переменную указанного типа, допускается применение списка с запятыми:
Инициализация переменной
Перед использованием переменной, нужно задать ей начальное значение. Этот процесс называется инициализация. Без инициализации мы можем получить ошибку во время выполнения программы, поэтому инициализация очень важна. Для инициализации переменной используют оператор присваивания. Слева указывается имя переменной, справа её значение.
Вот пример инициализации:
Ниже посмотрим другие примеры инициализации и объявления переменных в Java:
Типы переменных в Java
Продолжаем наш небольшой урок для начинающих, посвящённый инициализации переменных в Java. Итак, можно выделить 3 типа переменных: - локальные; - статические (переменные класса); - переменные экземпляра.
Теперь давайте рассмотрим их подробнее.
Локальные переменные в Java
Свойства локальных переменных: - объявляются в методах, блоках или конструкторах; - создаются, когда метод, блок или конструктор запускаются; - уничтожаются после завершения метода, конструктора либо блока; - видимы лишь в пределах объявленного метода, блока либо конструктора; - реализуются на уровне стека внутри; - в Java не существует значений по умолчанию для локальных переменных, поэтому они должны объявляться и проходить этап инициализации непосредственно перед первым использованием; - для переменной нельзя использовать модификаторы доступа.
Пример локальных переменных
В итоге мы получим следующий результат:
Пример локальных переменных без инициализации
Запустив компиляцию без инициализации, мы увидим следующую ошибку:
Пожалуй, об инициализации уже поговорили достаточно. Идём дальше.
Переменные экземпляра
Результат работы нашей программы следующий:
Рассмотрение переменных класса (статических переменных в Java) выходит за рамки нашей статьи. Давайте лучше поговорим о том, что такое константа и зачем нужны константы в Java.
Для чего используются константы?
Константы применяются в Java для хранения данных. Константа отличается от переменной. Главное отличие в том, что при использовании константы мы можем присвоить значение лишь один раз.
В остальном константа объявляется так же, как и переменная. Правда, в случае использования константы сначала идёт ключевое слово final:
Как правило, при записи имени константы применяют верхний регистр.
Читайте также: