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

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

Вступление

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

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

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

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

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

 global a_variable = 5 

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

 int aVariable = 3; 
 
 int someFunction() { 
 print(aVariable); 
 } 

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

 int aVariable = 3; 
 
 int someFunction() { 
 int aVariable = 7; 
 print(aVariable); 
 } 

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

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

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

 public int setNumber(int number) { 
 this.number = number; 
 } 

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

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

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

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

 class GridCoordinate { 
 int x; 
 int y; 
 } 

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

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

 global ver = 2.55 

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

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

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

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

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

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

 public class Reference { 
 public static final double VERSION_NUMBER; 
 public static final String DATABASE_URL; 
 public static final Database DATABASE; 
 } 

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

 public int someMethod() { 
 System.out.println(Reference.VERSION_NUMBER); 
 } 

Наличие 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() { return DATABASE_URL} 

В этом примере 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
comments powered by Disqus