Как объявить глобальную переменную в java

Как создать глобальную переменную в java

В Java глобальные переменные, которые могут быть доступны в любом месте программы, обычно объявляются как поля класса. Для объявления поля класса используется модификатор доступа, за которым следует тип поля и его имя. Например:

public class MyClass  public int myGlobalVariable; > 

Здесь myGlobalVariable является глобальной переменной, доступной из любого метода объекта MyClass , а также из других объектов этого класса.

Также можно объявить статическую переменную класса, которая будет доступна как глобальная переменная для всех экземпляров этого класса, а также из других классов. Для объявления статической переменной используется модификатор static Например:

public class MyClass  public static int myGlobalVariable; > 

Rukovodstvo

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

Использование глобальных переменных / констант в Java

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

Время чтения: 5 мин.

Вступление

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

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

В этой статье мы рассмотрим эмуляцию и использование глобальных переменных в Java .

Что такое глобальная переменная?

Глобальная переменная — это переменная, к которой можно получить доступ из любой области. Многие языки программирования имеют специальный синтаксис для объявления глобальной переменной, например, Python позволяет нам использовать ключевое слово global

 global a_variable = 5 

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

 int aVariable = 3; int someFunction()

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

 int aVariable = 3; int someFunction()

В зависимости от языка это обычно выполняется одним из трех способов:

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

Третий метод — это то, как Java обрабатывает переменные экземпляра, когда параметр метода использует то же имя. Представьте класс с переменной, объявленной как private int number . Чтобы изменить значение number позже, вы можете создать функцию:

 public int setNumber(int number)

this показывает, что вам нужен number из класса, а не из параметров метода.

Почему Java не использует глобальные переменные?

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

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

 class GridCoordinate

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

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

 global ver = 2.55 

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

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

Как эмулировать глобальную переменную в Java?

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

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

Обычно вы можете создать Constants или Reference класс, в котором вы храните различные «глобальные» значения, если они обычно используются в других частях приложения. Одна переменная не обязательно гарантирует наличие всего класса, поэтому вы можете объединить многие из них в один класс Reference или Constants

 public class Reference

Затем к этим переменным можно будет получить доступ в другом месте, обратившись к классу:

 public int someMethod()

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

Лучшим способом использования Reference было бы рассматривать все переменные как частные и использовать методы получения для управления всем доступом к значениям. Также разумно использовать константы вместо переменных для данных, которые не должны изменяться во время работы программы. Например:

 private static final String DATABASE_URL = "https://databaseurl.db/database"; private static final Database DATABASE = Database.connect(databaseURL); public static Database getDatabase() < return DATABASE; >public static String getUrl()

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

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

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

 public static final int GENERATION_SIZE; public static final int GENOME_SIZE; public static final int REPRODUCTION_SIZE; public static final int MAX_ITERATIONS; 

Затем вы получите доступ к ним через их общедоступный класс, например:

 for(int i = 0; i < Constants.MAX_ITERATIONS; i++) < // . >

Заключение

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

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

В этой статье мы рассмотрели, как эмулировать глобальные переменные в Java .

Licensed under CC BY-NC-SA 4.0

8. Java – Типы переменных, объявление и инициализация

Переменная предоставляется нам именем хранения, чтобы нашей программой можно было манипулировать. Каждая переменная в 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.

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

Оглавление

• 1. Java – Самоучитель для начинающих
• 2. Java – Обзор языка
• 3. Java – Установка и настройка
• 4. Java – Синтаксис
• 5. Java – Классы и объекты
• 6. Java – Конструкторы
• 7. Java – Типы данных и литералы
• 8. Java – Типы переменных
• 9. Java – Модификаторы
• 10. Java – Операторы
• 11. Java – Циклы и операторы цикла
• 11.1. Java – Цикл while
• 11.2. Java – Цикл for
• 11.3. Java – Улучшенный цикл for
• 11.4. Java – Цикл do..while
• 11.5. Java – Оператор break
• 11.6. Java – Оператор continue
• 12. Java – Операторы принятия решений
• 12.1. Java – Оператор if
• 12.2. Java – Оператор if..else
• 12.3. Java – Вложенный оператор if
• 12.4. Java – Оператор switch..case
• 12.5. Java – Условный оператор (? 🙂
• 13. Java – Числа
• 13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
• 13.2. Java – Метод compareTo()
• 13.3. Java – Метод equals()
• 13.4. Java – Метод valueOf()
• 13.5. Java – Метод toString()
• 13.6. Java – Метод parseInt()
• 13.7. Java – Метод Math.abs()
• 13.8. Java – Метод Math.ceil()
• 13.9. Java – Метод Math.floor()
• 13.10. Java – Метод Math.rint()
• 13.11. Java – Метод Math.round()
• 13.12. Java – Метод Math.min()
• 13.13. Java – Метод Math.max()
• 13.14. Java – Метод Math.exp()
• 13.15. Java – Метод Math.log()
• 13.16. Java – Метод Math.pow()
• 13.17. Java – Метод Math.sqrt()
• 13.18. Java – Метод Math.sin()
• 13.19. Java – Метод Math.cos()
• 13.20. Java – Метод Math.tan()
• 13.21. Java – Метод Math.asin()
• 13.22. Java – Метод Math.acos()
• 13.23. Java – Метод Math.atan()
• 13.24. Java – Метод Math.atan2()
• 13.25. Java – Метод Math.toDegrees()
• 13.26. Java – Метод Math.toRadians()
• 13.27. Java – Метод Math.random()
• 14. Java – Символы
• 14.1. Java – Метод Character.isLetter()
• 14.2. Java – Метод Character.isDigit()
• 14.3. Java – Метод Character.isWhitespace()
• 14.4. Java – Метод Character.isUpperCase()
• 14.5. Java – Метод Character.isLowerCase()
• 14.6. Java – Метод Character.toUpperCase()
• 14.7. Java – Метод Character.toLowerCase()
• 14.8. Java – Метод Character.toString()
• 15. Java – Строки
• 15.1. Java – Метод charAt()
• 15.2. Java – Метод compareTo()
• 15.3. Java – Метод compareToIgnoreCase()
• 15.4. Java – Метод concat()
• 15.5. Java – Метод contentEquals()
• 15.6. Java – Метод copyValueOf()
• 15.7. Java – Метод endsWith()
• 15.8. Java – Метод equals()
• 15.9. Java – Метод equalsIgnoreCase()
• 15.10. Java – Метод getBytes()
• 15.11. Java – Метод getChars()
• 15.12. Java – Метод hashCode()
• 15.13. Java – Метод indexOf()
• 15.14. Java – Метод intern()
• 15.15. Java – Метод lastIndexOf()
• 15.16. Java – Метод length()
• 15.17. Java – Метод matches()
• 15.18. Java – Метод regionMatches()
• 15.19. Java – Метод replace()
• 15.20. Java – Метод replaceAll()
• 15.21. Java – Метод replaceFirst()
• 15.22. Java – Метод split()
• 15.23. Java – Метод startsWith()
• 15.24. Java – Метод subSequence()
• 15.25. Java – Метод substring()
• 15.26. Java – Метод toCharArray()
• 15.27. Java – Метод toLowerCase()
• 15.28. Java – Метод toString()
• 15.29. Java – Метод toUpperCase()
• 15.30. Java – Метод trim()
• 15.31. Java – Метод valueOf()
• 15.32. Java – Классы StringBuilder и StringBuffer
• 15.32.1. Java – Метод append()
• 15.32.2. Java – Метод reverse()
• 15.32.3. Java – Метод delete()
• 15.32.4. Java – Метод insert()
• 15.32.5. Java – Метод replace()
• 16. Java – Массивы
• 17. Java – Дата и время
• 18. Java – Регулярные выражения
• 19. Java – Методы
• 20. Java – Потоки ввода/вывода, файлы и каталоги
• 20.1. Java – Класс ByteArrayInputStream
• 20.2. Java – Класс DataInputStream
• 20.3. Java – Класс ByteArrayOutputStream
• 20.4. Java – Класс DataOutputStream
• 20.5. Java – Класс File
• 20.6. Java – Класс FileReader
• 20.7. Java – Класс FileWriter
• 21. Java – Исключения
• 21.1. Java – Встроенные исключения
• 22. Java – Вложенные и внутренние классы
• 23. Java – Наследование
• 24. Java – Переопределение
• 25. Java – Полиморфизм
• 26. Java – Абстракция
• 27. Java – Инкапсуляция
• 28. Java – Интерфейсы
• 29. Java – Пакеты
• 30. Java – Структуры данных
• 30.1. Java – Интерфейс Enumeration
• 30.2. Java – Класс BitSet
• 30.3. Java – Класс Vector
• 30.4. Java – Класс Stack
• 30.5. Java – Класс Dictionary
• 30.6. Java – Класс Hashtable
• 30.7. Java – Класс Properties
• 31. Java – Коллекции
• 31.1. Java – Интерфейс Collection
• 31.2. Java – Интерфейс List
• 31.3. Java – Интерфейс Set
• 31.4. Java – Интерфейс SortedSet
• 31.5. Java – Интерфейс Map
• 31.6. Java – Интерфейс Map.Entry
• 31.7. Java – Интерфейс SortedMap
• 31.8. Java – Класс LinkedList
• 31.9. Java – Класс ArrayList
• 31.10. Java – Класс HashSet
• 31.11. Java – Класс LinkedHashSet
• 31.12. Java – Класс TreeSet
• 31.13. Java – Класс HashMap
• 31.14. Java – Класс TreeMap
• 31.15. Java – Класс WeakHashMap
• 31.16. Java – Класс LinkedHashMap
• 31.17. Java – Класс IdentityHashMap
• 31.18. Java – Алгоритмы Collection
• 31.19. Java – Iterator и ListIterator
• 31.20. Java – Comparator
• 32. Java – Дженерики
• 33. Java – Сериализация
• 34. Java – Сеть
• 34.1. Java – Обработка URL
• 35. Java – Отправка Email
• 36. Java – Многопоточность
• 36.1. Java – Синхронизация потоков
• 36.2. Java – Межпоточная связь
• 36.3. Java – Взаимная блокировка потоков
• 36.4. Java – Управление потоками
• 37. Java – Основы работы с апплетами
• 38. Java – Javadoc

Область видимости переменной в Java

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

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

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

1. Создайте новую программу с именем Scope, содержащую стандартный метод main.

class Scope < public static void main ( String [ ] args ) < >

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

String txt = «Это локальная переменная метода main» ;
System . out . println ( txt ) ;

3. После главного метода перед последней фигурной скобкой класса добавьте еще один метод с именем sub.

public static void sub ( ) < >

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

String txt = «Это локальная переменная метода sub» ;
System . out . println ( txt ) ;

5. Добавьте вызов метода sub в конец метода main.

6. Сохраните программу под именем Scope.java, затем скомпилируй-те и запустите. Код должен выглядеть так:

class Scope < public static void main ( String [ ] args ) < String txt = "Это локальная переменная метода main" ; System . out . println ( txt ) ; public static void sub ( ) < String txt = "Это локальная переменная метода sub" ; System . out . println ( txt ) ;

После компиляции получаем:

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

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

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

7. Отредактируйте код в вашем файле Scope.java, добавив глобальную переменную класса с тем же именем, что и локальная переменная метода.