Как вы определяете глобальные переменные в Java?
Глобальные переменные в Java
Ответ 1
Чтобы определить глобальную переменную, вы можете использовать статическое ключевое слово
public class Example {
public static int a;
public static int b;
}
теперь вы можете получить доступ к a и b из любого места позвонив
Example.a;
Example.b;
Ответ 2
Нет. Это по дизайну. Вы не должны этого делать, даже если бы могли.
При этом вы можете создать набор открытых статических членов в классе с именем Globals.
public class Globals {
public static int globalInt = 0;
///
}
но вы действительно не должны:). Серьезно.. не делай этого.
Ответ 3
Другой способ - создать такой интерфейс:
public interface GlobalConstants
{
String name = "Chilly Billy";
String address = "10 Chicken head Lane";
}
Любой класс, который должен их использовать, должен реализовать интерфейс:
public class GlobalImpl implements GlobalConstants
{
public GlobalImpl()
{
System.out.println(name);
}
}
Ответ 4
Вам лучше использовать инъекцию зависимостей:
public class Globals {
public int a;
public int b;
}
public class UsesGlobals {
private final Globals globals;
public UsesGlobals(Globals globals) {
this.globals = globals;
}
}
Ответ 5
Вообще говоря, в программе java OO нет понятия "GLOBAL"
Тем не менее, есть какая-то правда, стоящая за вашим вопросом, потому что будут случаи, когда вы хотите запустить метод в любой части программы. Например, метод random() в приложении Phrase-O-Matic, метод должен быть доступен из любой точки программы.
Итак, чтобы удовлетворить такие вещи, как выше "Нам нужны глобальные переменные и методы"
ЗАКЛЮЧИТЬ ПЕРЕМЕННЫЙ КАК ГЛОБАЛЬНЫЙ.
1.Mark the variable as public static final While declaring.
ЗАКЛЮЧИТЬ МЕТОД КАК ГЛОБАЛЬНЫЙ.
1. Mark the method as public static While declaring.
Поскольку я объявлял глобальные переменные и метод как статические, вы можете называть их в любом месте, которое вы хотите, просто с помощью следующего кода
ClassName.X
ПРИМЕЧАНИЕ: X может быть именем метода или именем переменной в соответствии с требованием, а ClassName - это имя класса, в котором вы его объявили.
Ответ 6
Множество хороших ответов, но я хочу привести этот пример, так как он рассматривал более правильный способ доступа к переменным класса другим классом: использование методов получения и установки.
Причина, по которой вы используете геттеры и сеттеры таким образом, а не просто делаете переменную общедоступной, заключается в следующем. Допустим, ваш var будет глобальным параметром, который вы НИКОГДА не хотите, чтобы кто-то изменил во время выполнения вашей программы (в случае, когда вы разрабатываете код с командой), что-то вроде, возможно, URL-адреса веб-сайта. Теоретически это может измениться и может многократно использоваться в вашей программе, поэтому вы хотите использовать глобальную переменную, чтобы иметь возможность обновлять все сразу. Но вы не хотите, чтобы кто-то другой вошел и изменил эту переменную (возможно, даже не осознавая, насколько это важно). В этом случае вы просто не включаете метод установки, а только метод получения.
public class Global{
private static int var = 5;
public static int getVar(){
return Global.var;
}
//If you do not want to change the var ever then do not include this
public static void setVar(int var){
Global.var = var;
}
}
Ответ 7
Ничто не должно быть глобальным, кроме констант.
public class MyMainClass {
public final static boolean DEBUGMODE=true;
}
Поместите это в свой основной класс. В других .java файлах используйте его через:
if(MyMainClass.DEBUGMODE) System.out.println("Some debugging info");
Удостоверьтесь, что когда вы переводите код с пола режущей комнаты и в выпуск вы удаляете или комментируете эту функциональность.
Если у вас есть метод workhorse, например рандомизатор, я предлагаю создать пакет "Toolbox"! Все кодеры должны иметь один, тогда всякий раз, когда вы хотите использовать его в .java, просто импортируйте его!
Ответ 8
В Java нет глобальной переменной
Тем не менее, у нас есть static ключевое слово, и это все, что нам нужно. Ничто не существует вне класса в Java. Ключевое слово static представляет переменную класса, которая, в отличие от переменной экземпляра, имеет только одну копию и которая распространяется на все экземпляры этого класса, что означает, что ее значение можно изменить и получить доступ ко всем экземплярам в любой точке.
Если вам нужна глобальная переменная, к которой можно получить доступ за пределами области действия, то эта переменная вам нужна, но ее область действия существует только там, где находится класс, и это будет все.
Ответ 9
В Java нет такой вещи, как действительно глобальная переменная. Каждая статическая переменная должна принадлежать к некоторому классу (например, System.out), но когда вы решили, какой класс он войдет, вы можете ссылаться на нее повсюду, загружаемую одним и тем же загрузчиком классов.
Обратите внимание, что статические переменные всегда должны быть защищены при обновлении, чтобы избежать условий гонки.
Ответ 10
public class GlobalClass {
public static int x = 37;
public static String s = "aaa";
}
Таким образом вы можете получить к ним доступ с помощью GlobalClass.x и GlobalClass.s
Ответ 11
public class GlobalImpl {
public static int global = 5;
}
вы можете звонить в любом месте:
GlobalImpl.global // 5
Ответ 12
Обычно глобальная переменная (я предполагаю, что вы сравниваете ее с C, Cpp), определяете как public static final
как
class GlobalConstant{
public static final String CODE = "cd";
}
ENUMs также полезны в таком сценарии:
Пример Calendar.JANUARY)
Ответ 13
Как вы наверное догадались из ответа, в Java нет глобальных переменных, и единственное, что вы можете сделать, это создать класс со статическими членами:
public class Global {
public static int a;
}
Вы можете использовать его с Global.a в другом месте. Однако, если вы используете Java 1.5 или лучше, вы можете использовать магию import static, чтобы она выглядела еще больше как реальная глобальная переменная:
import static test.Global.*;
public class UseGlobal {
public void foo() {
int i = a;
}
}
И вуаля!
Теперь это далеко не самая лучшая практика, чтобы вы могли видеть в рекламных роликах: не делайте этого дома
Ответ 14
В Java нет глобальных переменных, но есть глобальные классы с общедоступными полями. Вы можете использовать функцию статического импорта java 5, чтобы она выглядела почти как глобальные переменные.
Ответ 15
Создание независимого файла, например. Example.java, чтобы использовать 1-е решение, отлично. Вы можете сделать это и в приложении, если, например, глобальные переменные являются особенными для вашего текущего приложения и т.д.:
Создайте класс в начале и объявите здесь свои переменные:
class Globals {
static int month_number;
static String month_name;
}
Затем вы можете получить доступ к этим переменным - используя их как "Globals.month_number" и т.д. - из любого места в вашем приложении.
Ответ 16
Если вам нужно обновить глобальное свойство, в качестве глобальной переменной можно использовать простой класс-оболочку getter/setter. Типичный пример показан ниже.
public class GlobalHolder {
private static final GlobalHolder INSTANCE = new GlobalHolder();
private volatile int globalProperty;
public static GlobalHolder getInstance() {
return INSTANCE;
}
public int getGlobalProperty() {
return globalProperty;
}
public void setGlobalProperty(int globalProperty) {
this.globalProperty = globalProperty;
}
public static void main(String[] args) {
GlobalHolder.getInstance().setGlobalProperty(10);
System.out.println(GlobalHolder.getInstance().getGlobalProperty());
}
}
Ответ 17
В общем, Java не имеет глобальных переменных. За исключением локальных переменных, все переменные входят в область действия любого класса, определенного в программе. Мы можем иметь статические переменные, чтобы иметь область видимости глобальных переменных.
Ответ 18
По идее глобальные переменные, также известные как переменная экземпляра, являются переменными уровня класса, то есть они определены внутри класса, но вне методов. Чтобы сделать их доступными полностью и использовать их напрямую, укажите ключевое слово static. Поэтому, если я пишу программу для простой арифметической операции и ей требуется числовая пара, то две переменные экземпляра определяются как таковые:
public class Add {
static int a;
static int b;
static int c;
public static void main(String arg[]) {
c=sum();
System.out.println("Sum is: "+c);
}
static int sum() {
a=20;
b=30;
return a+b;
}
}
Output: Sum is: 50
Кроме того, использование статического ключевого слова до переменных экземпляра позволяет нам не указывать типы данных для одинаковых переменных снова и снова. Просто напишите переменную напрямую.
Ответ 19
без static это тоже возможно:
class Main {
String globalVar = "Global Value";
class Class1 {
Class1() {
System.out.println("Class1: "+globalVar);
globalVar += " - changed";
} }
class Class2 {
Class2() {
System.out.println("Class2: "+globalVar);
} }
public static void main(String[] args) {
Main m = new Main();
m.mainCode();
}
void mainCode() {
Class1 o1 = new Class1();
Class2 o2 = new Class2();
}
}
/*
Output:
Class1: Global Value
Class2: Global Value - changed
*/
Ответ 20
Объектно-ориентированное программирование построено с пониманием того, что область видимости переменных тесно связана с объектом класса, который инкапсулирует эти переменные.
Проблема с созданием "глобальных переменных" заключается в том, что это не отраслевой стандарт для Java. Это не отраслевой стандарт, поскольку он позволяет нескольким классам манипулировать данными в асинхронном режиме. Если вы используете многопоточное приложение, это становится немного сложнее и опаснее с точки зрения безопасности потоков. Существуют и другие причины, по которым использование глобальных переменных неэффективно, но если вы хотите этого избежать, я предлагаю вам обратиться к аспектно-ориентированному программированию.
Аспектно-ориентированное программирование снимает эту проблему, возлагая на родительский класс ответственность за область действия через что-то, называемое "советами", что добавляет к поведению дополнительный код, фактически не изменяя его. Он предлагает решения для сквозных задач или использования глобальных переменных.
Spring - это Java-фреймворк, использующий AOP, и хотя он традиционно используется для веб-приложений, базовое приложение может использоваться повсеместно в Java-фреймворке (включая 8.0). Это может быть направление, которое вы хотите изучить больше.
Ответ 21
Понимание проблемы
Я рассматриваю квалификацию глобальной переменной как переменную, к которой можно обращаться и изменять в любом месте кода, не заботясь о статическом вызове/вызове экземпляра или передаче любой ссылки из одного класса в другой.
Обычно, если у вас есть класс А
public class A {
private int myVar;
public A(int myVar) {
this.myVar = myVar;
}
public int getMyVar() {
return myVar;
}
public void setMyVar(int mewVar) {
this.myVar = newVar;
}
}
и хочу получить доступ и обновить myvar в классе B,
public class B{
private A a;
public void passA(A a){
this.a = a;
}
public void changeMyVar(int newVar){
a.setMyvar(newVar);
}
}
вам нужно будет иметь ссылку на экземпляр класса A и обновить значение в классе B следующим образом:
int initialValue = 2;
int newValue = 3;
A a = new A(initialValue);
B b = new B();
b.passA(a);
b.changeMyVar(newValue);
assertEquals(a.getMyVar(),newValue); // true
Решение
Поэтому мое решение (даже если я не уверен, что это хорошая практика) - использовать синглтон:
public class Globals {
private static Globals globalsInstance = new Globals();
public static Globals getInstance() {
return globalsInstance;
}
private int myVar = 2;
private Globals() {
}
public int getMyVar() {
return myVar;
}
public void setMyVar(int myVar) {
this.myVar = myVar;
}
}
Теперь вы можете получить уникальный экземпляр Global в любом месте с помощью:
Globals globals = Globals.getInstance();
// and read and write to myVar with the getter and setter like
int myVar = globals.getMyVar();
global.setMyVar(3);
Ответ 22
// Get the access of global while retaining priveleges.
// You can access variables in one class from another, with provisions.
// The primitive must be protected or no modifier (seen in example).
// the first class
public class farm{
int eggs; // an integer to be set by constructor
fox afox; // declaration of a fox object
// the constructor inits
farm(){
eggs = 4;
afox = new fox(); // an instance of a fox object
// show count of eggs before the fox arrives
System.out.println("Count of eggs before: " + eggs);
// call class fox, afox method, pass myFarm as a reference
afox.stealEgg(this);
// show the farm class, myFarm, primitive value
System.out.println("Count of eggs after : " + eggs);
} // end constructor
public static void main(String[] args){
// instance of a farm class object
farm myFarm = new farm();
}; // end main
} // end class
// the second class
public class fox{
// theFarm is the myFarm object instance
// any public, protected, or "no modifier" variable is accessible
void stealEgg(farm theFarm){ --theFarm.eggs; }
} // end class
Ответ 23
Чтобы определить глобальную переменную, вы можете использовать статическое ключевое слово
public final class Tools {
public static int a;
public static int b;
}
теперь вы можете получить доступ к a и b из любого места, вызывая
Tools.a;
Tools.b;
Yoy правы... специально в J2ME... Вы можете избежать NullPointerException, вставив внутри своего конструктора MidLet (proggy initialization) эта строка кода:
new Tools();
Это гарантирует, что Инструменты будут выделены перед любой инструкцией который использует его.
Что это!