Глобальные переменные в Java

Question

Как вы определяете глобальные переменные в Java?

Answer 1

public class GlobalImpl {   

 public static int global = 5;

}

Вы можете позвонить куда хотите:

GlobalImpl.global // 5

Answer 2

Если вам нужно обновить глобальное свойство, в качестве глобальной переменной можно использовать простой класс-оболочку 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());
    }
}

Answer 3

Создание независимого файла, например.Example.java использовать 1-е решение, просто отлично.Вы можете сделать это также в приложении, если, например, глобальные переменные являются особенными для вашего текущего приложения и т. Д.:1005 * Затем вы можете получить доступ к этим переменным - используя их как «Globals.month_number» и т. Д. - из любого места в вашем приложении.

Answer 4

Как правило, глобальная переменная (я предполагаю, что вы сравниваете ее с C, Cpp), определяется как public static final

подобно

class GlobalConstant{
    public static final String CODE  = "cd";
}

ENUM также полезны в таком сценарии:

Например Calendar.JANUARY)

Answer 5

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

Answer 6

Как вы, вероятно, догадались из ответа, в 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;
    }
}

и voilà !

Теперь это далеко не лучшая практика, так как вы можете видеть в рекламе: не делайте этого дома

Answer 7

Понимание проблемы

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

Обычно, если у вас есть класс А

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);

Answer 8

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

Проблема создания «глобальных переменных» заключается в том, что это не является отраслевым стандартом для Java.Это не отраслевой стандарт, поскольку он позволяет нескольким классам манипулировать данными асинхронно, если вы используете многопоточное приложение, это становится немного сложнее и опаснее с точки зрения безопасности потоков.Есть различных других причин , почему использование глобальных переменных неэффективно, но если вы хотите этого избежать, я предлагаю вам прибегнуть к Аспектно-ориентированному программированию .

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

Spring - это фреймворк Java, использующий AOP, и хотя он традиционно используется для веб-приложений, базовое приложение может использоваться повсеместно в рамках фреймворка Java (включая 8.0).Это может быть направление, которое вы хотите изучить больше.

Answer 9

без 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
*/

Answer 10

Исходя из концепции, глобальные переменные, также известные как переменные экземпляра, являются переменными уровня класса, т. Е. Они определены внутри класса, но вне методов.Чтобы сделать их полностью доступными и использовать их, предоставьте ключевое слово 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

Более того, использование статического ключевого слова перед переменными экземпляра позволяет нам не указывать типы данныхдля тех же переменных снова и снова.Просто напишите переменную напрямую.