Как создать глобальную переменную в java
В Java глобальные переменные, которые могут быть доступны в любом месте программы, обычно объявляются как поля класса. Для объявления поля класса используется модификатор доступа, за которым следует тип поля и его имя. Например:
Здесь myGlobalVariable является глобальной переменной, доступной из любого метода объекта MyClass , а также из других объектов этого класса.
Также можно объявить статическую переменную класса, которая будет доступна как глобальная переменная для всех экземпляров этого класса, а также из других классов. Для объявления статической переменной используется модификатор static Например:
Rukovodstvo
статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.
Использование глобальных переменных / констант в Java
Введение Объектно-ориентированная структура кода Java может затруднить обращение к переменным в нескольких местах. Иногда бывает трудно решить, к какому классу должна входить данная переменная, особенно если это широко используемое значение, такое как коннектор базы данных или математическая константа. Во многих языках, когда мы сталкиваемся с подобной проблемой, мы можем объявить глобальную переменную. Хотя, к сожалению, Java технически не позволяет создавать переменные в глобальной области видимости. В этом
Время чтения: 5 мин.
Вступление
Объектно-ориентированная структура кода Java может затруднить обращение к переменным в нескольких местах. Иногда бывает трудно решить, к какому классу должна входить данная переменная, особенно если это широко используемое значение, такое как коннектор базы данных или математическая константа.
Во многих языках, когда мы сталкиваемся с подобной проблемой, мы можем объявить глобальную переменную. Хотя, к сожалению, Java технически не позволяет создавать переменные в глобальной области видимости.
В этой статье мы рассмотрим эмуляцию и использование глобальных переменных в Java .
Что такое глобальная переменная?
Глобальная переменная — это переменная, к которой можно получить доступ из любой области. Многие языки программирования имеют специальный синтаксис для объявления глобальной переменной, например, Python позволяет нам использовать ключевое слово global
C создает глобальные объекты, просто объявляя переменную вне функции.
Независимо от синтаксиса создания глобальной переменной, они работают более или менее одинаково. Они позволяют вам получить доступ и изменить значение из любого другого класса или функции. Это может вызвать проблемы, если вы попытаетесь повторно использовать имя в другой области. Например:
В зависимости от языка это обычно выполняется одним из трех способов:
- Выдает ошибку при объявлении уже существующей переменной.
- Предположим, что оператор печати ссылается на локальную переменную.
- Предположим, что оператор печати ссылается на локальную переменную, если для ссылки на глобальную переменную не используется специальный синтаксис.
Третий метод — это то, как Java обрабатывает переменные экземпляра, когда параметр метода использует то же имя. Представьте класс с переменной, объявленной как private int number . Чтобы изменить значение number позже, вы можете создать функцию:
this показывает, что вам нужен number из класса, а не из параметров метода.
Почему Java не использует глобальные переменные?
Краткий ответ на этот вопрос: преднамеренный дизайн. Java была создана как чисто объектно-ориентированный язык программирования, поэтому все, что вы создаете, заключено в класс.
Будучи чисто объектно-ориентированным, разработчикам рекомендуется хранить связанные переменные и функции вместе, что делает программу в целом более организованной. Это также может помочь в определении цели плохо документированной переменной. Например:
Без знания того, что эти переменные были частью GridCoordinate , их было бы почти невозможно идентифицировать. С учетом контекста имени класса мы можем сделать вывод, что это горизонтальное и вертикальное положение данной точки на сетке.
А теперь представьте, что вы работаете в составе полностью удаленной команды с членами по всему миру. Вы и ваш коллега на другом континенте работаете над одним и тем же файлом, когда вы оба сталкиваетесь с этим:
Вы предполагаете, что переменная представляет собой номер версии. Ваш коллега думает, что это может иметь какое-то отношение к вертикальной оси. Вы оба вносите изменения в разные функции на основе своих предположений, изменяя значение и ссылаясь на него по своему усмотрению.
Это ситуация, которой Java пытается избежать, не имея глобальных переменных. Использование глобальных переменных в большом проекте может привести к непреднамеренному и неожиданному поведению, поскольку переменные объявляются и изменяются в разных частях кода.
Как эмулировать глобальную переменную в Java?
Хотя использование глобальных переменных имеет некоторые недостатки, бывают случаи, когда вам может потребоваться доступ к переменной во многих местах, но вы можете почувствовать, что это не гарантирует создания специального класса-оболочки.
Например, вы можете захотеть сослаться на подключение к базе данных в нескольких классах, но не объявили DatabaseConnection для обработки всех функций вашей базы данных. Вы также можете просто предпочесть просто использовать встроенные методы из выбранной вами библиотеки базы данных без оболочки для обработки транзакций.
Обычно вы можете создать Constants или Reference класс, в котором вы храните различные «глобальные» значения, если они обычно используются в других частях приложения. Одна переменная не обязательно гарантирует наличие всего класса, поэтому вы можете объединить многие из них в один класс Reference или Constants
Затем к этим переменным можно будет получить доступ в другом месте, обратившись к классу:
Наличие Reference позволяет легко узнать, где искать комментарии, объясняющие назначение переменной. Если бы указанные выше переменные были созданы как настоящие глобальные переменные, скорее всего, они были бы созданы в разных файлах, что затрудняет поиск предполагаемой цели автора.
Лучшим способом использования Reference было бы рассматривать все переменные как частные и использовать методы получения для управления всем доступом к значениям. Также разумно использовать константы вместо переменных для данных, которые не должны изменяться во время работы программы. Например:
В этом примере URL-адрес базы данных и соединение с базой данных не могут быть изменены где-либо еще в коде, но соединение с базой данных может использоваться по мере необходимости для транзакций.
Хотя синтаксически это не так чисто, как определение глобальной переменной, оно может обеспечить такой же уровень свободы.
Другое распространенное использование — определение некоторых констант в приложении с неизменяемыми значениями, которые вы часто используете. Например, если вы тренируете нейронную сеть или запускаете генетические алгоритмы, повсюду будут использоваться различные значения:
Затем вы получите доступ к ним через их общедоступный класс, например:
Заключение
Глобальные переменные часто рассматриваются как тема, вызывающая разногласия, и многие разработчики говорят, что их никогда не следует использовать. Эти разработчики обычно утверждают, что глобальные переменные усложняют сопровождение кода. Однако есть некоторые случаи, когда глобальные переменные полезны, если они хорошо организованы и четко определены.
В конечном итоге решение об их использовании ложится на вас или на одного из старших членов команды разработчиков.
В этой статье мы рассмотрели, как эмулировать глобальные переменные в Java .
Глобальные переменные в Java
Вы этого не сделаете. Это задумано. Вы не должны этого делать, даже если бы могли.
При этом вы можете создать набор общедоступных статических членов в классе с именем Globals.
но не стоит :). Серьезно .. не делай этого.
Другой способ — создать такой интерфейс:
Любой класс, которому необходимо их использовать, должен только реализовать интерфейс:
Вам лучше использовать инъекцию зависимостей:
Много хороших ответов, но я хочу привести этот пример, поскольку он считается более правильным способом доступа к переменным одного класса другим классом: с помощью геттеров и сеттеров.
Причина, по которой вы используете методы получения и установки таким образом, вместо того, чтобы просто сделать переменную общедоступной, заключается в следующем. Допустим, ваш var будет глобальным параметром, который вы НИКОГДА не хотите, чтобы кто-то изменял во время выполнения вашей программы (в случае, когда вы разрабатываете код с командой), что-то вроде URL-адреса веб-сайта. Теоретически это может измениться и может использоваться много раз в вашей программе, поэтому вы хотите использовать глобальную переменную, чтобы иметь возможность обновлять все сразу. Но вы не хотите, чтобы кто-то другой вошел и изменил эту переменную (возможно, не осознавая, насколько это важно). В этом случае вы просто не включаете метод установки, а включаете только метод получения.
По правде говоря, в Java OO-программе нет концепции «GLOBAL».
Тем не менее, в вашем вопросе есть доля правды, потому что в некоторых случаях вы захотите запустить метод в любой части программы. Например — метод random () в приложении Phrase-O-Matic; это метод, который должен быть вызван из любой точки программы.
Итак, чтобы удовлетворить такие требования, как «Нам нужны глобальные переменные и методы»
ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ ГЛОБАЛЬНОЙ.
ОБЪЯВЛЕНИЕ МЕТОДА ГЛОБАЛЬНЫМ.
Поскольку я объявил глобальные переменные и метод как статические, вы можете вызывать их где угодно, просто с помощью следующего кода
ПРИМЕЧАНИЕ: X может быть либо именем метода, либо именем переменной в соответствии с требованиями, а ClassName — именем класса, в котором вы их объявили.
В Java нет глобальной переменной
Тем не менее, у нас есть ключевое слово static , и это все, что нам нужно. В Java ничего не существует вне класса. Ключевое слово static представляет переменную класса, которая, в отличие от переменной экземпляра, имеет только одну копию и распространяется на все экземпляры этого созданного класса, что означает, что его значение может быть изменено и доступно для всех экземпляров в любой момент.
Если вам нужна глобальная переменная, к которой можно получить доступ за пределами области действия, тогда это переменная, которая вам нужна, но ее область действия существует только там, где находится класс, и на этом все.
Ничего не должно быть глобальным, кроме констант.
Поместите это в свой основной класс. В других файлах .java используйте его через:
Убедитесь, что когда вы переносите свой код с пола монтажной в релиз, вы удаляете или закомментируете эту функциональность.
Если у вас есть метод «рабочей лошадки», например, рандомизатор, я предлагаю создать пакет «Toolbox»! Он должен быть у всех кодировщиков, тогда, когда вы захотите использовать его в .java, просто импортируйте его!
В Java нет такой вещи, как действительно глобальная переменная. Каждая статическая переменная должна принадлежать какому-либо классу (например, System.out), но когда вы решили, в какой класс она будет входить, вы можете ссылаться на нее отовсюду, загруженной одним и тем же загрузчиком классов.
Обратите внимание, что статические переменные всегда должны быть защищены при обновлении, чтобы избежать состояний гонки.
Таким образом, вы можете получить к ним доступ с помощью GlobalClass.x и GlobalClass.s
Вы можете звонить куда хотите:
Понимание проблемы
Я рассматриваю квалификацию глобальной переменной как переменной, к которой можно получить доступ и изменить в любом месте кода, не заботясь о статическом вызове / вызове экземпляра или передаче любой ссылки из одного класса в другой.
Обычно, если у вас класс А
и хотите получить доступ и обновить myvar в классе B,
вам потребуется ссылка на экземпляр класса A и обновить значение в классе B следующим образом:
Решение
Итак, мое решение (даже если я не уверен, что это хорошая практика) — использовать синглтон:
Теперь вы можете получить глобальный уникальный экземпляр где угодно с помощью:
Как вы, наверное, догадались из ответа, в Java нет глобальных переменных, и единственное, что вы можете сделать, — это создать класс со статическими членами:
Вы можете использовать его с Global.a в другом месте. Однако, если вы используете Java 1.5 или выше, вы можете использовать магию import static , чтобы она выглядела еще больше как настоящая глобальная переменная:
Это далеко не лучшая практика, как вы можете видеть в рекламе: не делайте этого дома
В Java нет глобальных переменных, но есть глобальные классы с общедоступными полями. Вы можете использовать статический импорт java 5, чтобы он выглядел почти как глобальные переменные.
Обычно глобальная переменная (я предполагаю, что вы сравниваете ее с C, Cpp) определяется как public static final
ENUM также полезны в таком сценарии:
Создание независимого файла, например. Example.java для использования 1-го решения вполне подойдет. Вы можете сделать это также в приложении, если, например, глобальные переменные являются специальными для вашего текущего приложения и т. д .:
Создайте класс в начале и объявите там свои переменные:
Затем вы можете получить доступ к этим переменным — используя их как Globals.month_number и т. Д. — из любого места в вашем приложении.
Если вам нужно обновить глобальное свойство, в качестве глобальной переменной можно использовать простой класс-оболочку получателя / сеттера. Типичный пример показан ниже.
но всегда хорошо, когда это возможно, определять локальные переменные внутри блоков методов.
Исходя из концепции, глобальные переменные, также известные как переменные экземпляра, являются переменными уровня класса, то есть они определены внутри класса, но вне методов. Чтобы сделать их полностью доступными и использовать напрямую, укажите ключевое слово static. Итак, если я пишу программу для простой арифметической операции и для нее требуется числовая пара, то две переменные экземпляра определяются как таковые:
Более того, использование ключевого слова static перед переменными экземпляра позволяет нам не указывать типы данных для одних и тех же переменных снова и снова. Просто напишите переменную напрямую.
В общем, в Java нет глобальных переменных. За исключением локальных переменных, все переменные попадают в область видимости любого класса, определенного в программе. У нас могут быть статические переменные, чтобы иметь область действия глобальных переменных.
без static это тоже возможно:
Объектно-ориентированное программирование строится с пониманием того, что область видимости переменных тесно связана с объектом класса, который инкапсулирует эти переменные.
Проблема с созданием «глобальных переменных» в том, что это не отраслевой стандарт для Java. Это не отраслевой стандарт, потому что он позволяет нескольким классам манипулировать данными асинхронно. Если вы запускаете многопоточное приложение, это становится немного сложнее и опаснее с точки зрения безопасности потоков. Существуют другие причины, почему использование глобальных переменных неэффективно, но если вы хотите этого избежать, я Предлагаем вам прибегнуть к аспектно-ориентированному программированию.
Аспектно-ориентированное программирование устраняет эту проблему, передавая родительскому классу ответственность за область действия с помощью так называемых «советов», которые добавляют к коду дополнительное поведение без фактического его изменения. Он предлагает решения для сквозных проблем или использования глобальных переменных.
Spring — это среда Java, использующая АОП, и хотя она традиционно используется для веб-приложений, основное приложение может быть используется повсеместно во всем фреймворке Java (включая версию 8.0). Возможно, это направление, в котором вы хотите исследовать больше.
Чтобы разрешить неквалифицированный доступ к статическим членам другого класса, вы также можете выполнить статический импорт:
Теперь вместо print(GlobalConstants.MY_PASSWORD);
вы можете напрямую использовать константу: print(MY_PASSWORD);
И рассмотрим ответ Эвана Левеска об интерфейсах для переноса констант.
Чтобы определить глобальную переменную, вы можете использовать статическое ключевое слово
теперь вы можете получить доступ к a и b из любого места, позвонив
Йой прав . особенно в J2ME . Вы можете избежать исключения NullPointerException, поместив в свой конструктор MidLet (инициализация проги) эту строку кода:
Это гарантирует, что Tools будет размещен перед любой инструкцией, которая его использует.
Using Global Variables/Constants in Java
Java's object-oriented code structure can make referencing variables in multiple places more difficult. It can also be difficult at times to decide which class a given variable should be a part of, especially if it's a widely used value like a database connector or mathematical constant.
In many languages, when faced with a problem like this, we can declare a global variable. Though, unfortunately, Java doesn't technically allow the creation of variables in a global scope.
In this article, we'll go over emulating and using global variables in Java.
What is a Global Variable?
A global variable is a variable which can be accessed from any scope. Many programming languages feature special syntax for declaring a global variable, for example, Python lets us use the global keyword:
C creates globals by simply declaring a variable outside a function.
Regardless of the syntax for creating the global variable, they work more or less the same way. They allow you to access and modify the value from inside any other class or function. This can cause problems if you try to re-use the name in another scope. For example:
Depending on the language, this is generally handled in one of three ways:
- Throw an error for declaring a variable that already exists.
- Assume the print statement references the local variable.
- Assume the print statement references the local variable unless special syntax is used to reference the global.
The third method is how Java handles instance variables when a method parameter uses the same name. Picture a class with a variable declared as private int number . To modify the value of number later on, you could create a function:
The this keyword shows that you want the number from the class, not from the method parameters.
Why Doesn't Java use Global Variables?
The short answer to this question is: intentional design. Java was created as a purely object-oriented programming language, which is why everything you create is wrapped in a class.
By being purely object-oriented, developers are encouraged to keep related variables and functions together, making the program as a whole more organized. This can also help with identifying the purpose of a poorly documented variable. For example:
Without the knowledge that these variables were part of a GridCoordinate class, it would be near impossible to identify them. With the context of the class name, we can infer they are the horizontal and vertical positions of a given point on a grid.
Now picture you're working as part of a fully remote team with members around the globe. You and a coworker on another continent are both working on the same file when you both come across this:
You make the assumption that the variable represents a version number. Your coworker thinks it might have something to do with a vertical axis. You both make changes to different functions based on your assumptions, modifying and referencing the value as you see fit.
This is the type of situation that Java tries to avoid by not having global variables. Using global variables in a large project can lead to unintended and unexpected behavior as variables are declared and modified in different sections of the code.
How to Emulate a Global Variable in Java?
Though there are some drawbacks to global variable use, there are times that you may want a variable to be accessed in many places, but you may feel that it doesn't warrant creating a dedicated wrapper class.
For example, you may want to reference your database connection in multiple classes, but haven't declared a DatabaseConnection class to handle all of your database functionality. You may also just prefer to just use the built-in methods from the database library of your choice without a wrapper to handle transactions.
Free eBook: Git Essentials
Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!
Usually, you can create a Constants or a Reference class, where you keep various "global" values stored if they're used commonly in other parts of the application. A single variable doesn't necessarily warrant an entire class, so you can encompass many of them in a single Reference or Constants class:
These variables can then be accessed elsewhere by referencing the class:
Having the Reference class makes it easy to know where to look for comments explaining the purpose of the variable. Had the variables above been created as true global variables, it's likely they would have been created in different files, making it harder to find the author's intended purpose.
A better way to use the Reference class would be to treat all variables as private, and use getter methods to control all access to the values. It is also wise to use constants instead of variables for data that should not change while the program is running. For example:
In this example, the database URL and database connection cannot be modified anywhere else in the code, but the database connection can be referenced as needed for transactions.
While this isn't quite as clean syntactically as defining a global variable, it can provide the same level of freedom.
Another common usage would be to define some constants in an application that has immutable values that you use often. For example, if you're training a Neural Network or running Genetic Algorithms, you'll have various values used all over the place:
Then, you'd access these through their public class, such as:
Conclusion
Global variables are often seen as a divisive topic, with many developers saying they should never be used. These developers generally argue that global variables make the code harder to maintain. There are, however, some instances where global-like variables are useful so long as they are well organized and clearly identified.
Ultimately, the decision to use them falls on you or a senior member of the development team.
In this article, we've gone over how to emulate global variables in Java.