Question

如何在Java中定义全局变量？

Answer 1

要定义全局变量，您可以使用静态关键字

public class Example {
    public static int a;
    public static int b;
}

现在您可以从任何地方访问a和b 通过调用

Example.a;

Example.b;

Answer 2

你没有。这是设计的。即使你可以，也不应该这样做。

话虽如此，您可以在名为Globals的类中创建一组公共静态成员。

public class Globals {
   public static int globalInt = 0;
   ///
}

但你真的不应该:)。说真的..不要这样做。

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

Answer 4

最好使用依赖注入：

public class Globals {
    public int a;
    public int b;
}

public class UsesGlobals {
    private final Globals globals;
    public UsesGlobals(Globals globals) {
        this.globals = globals;
    }
}

Answer 5

很多好的答案，但是我想给出这个例子，因为它被认为是另一个类访问类变量的更合适的方法：使用getter和setter。

您以这种方式使用getter和setter而不是仅将变量设为public的原因如下。让我们说你的var将是一个全局参数，你永远不希望有人在你的程序执行期间改变（在你用团队开发代码的情况下），比如网站的URL。从理论上讲，这可能会改变，并且可能会在程序中多次使用，因此您希望使用全局var来一次更新所有内容。但是你不希望别人进入并改变这个var（可能没有意识到它有多重要）。在这种情况下，您只是不包含setter方法，只包含getter方法。

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

Answer 6

说实话，java OO程序中没有“GLOBAL”的概念

然而，你的问题背后有一些事实，因为在某些情况下你想要在程序的任何部分运行一个方法。例如---在Phrase-O-Matic应用程序中的random（）方法;它是一个应该可以从程序的任何地方调用的方法。

因此，为了满足上述“我们需要具有类似全局变量和方法”的内容

宣布全球变量。

 1.Mark the variable as public static final While declaring.

宣布全球方法。

 1. Mark the method as public static While declaring.

因为我将全局变量和方法声明为静态，所以只需借助以下代码即可随意调用它们

ClassName.X

注意：根据要求，X可以是方法名称或变量名称，ClassName是您声明它们的类的名称。

Answer 7

除了常数之外，什么都不应该是全局的。

public class MyMainClass {
    public final static boolean DEBUGMODE=true;
}

将它放在你的主类中。在其他.java文件中，通过以下方式使用它：

if(MyMainClass.DEBUGMODE) System.out.println("Some debugging info");

确保当您将代码移出裁剪房间并释放时，您可以删除或注释掉此功能。

如果你有一个主力方法，比如随机发生器，我建议创建一个“工具箱”包！所有编码器都应该有一个，然后每当你想在.java中使用它时，只需导入它！

Answer 8

Java中没有全局变量

尽管如此，我们所拥有的是一个static关键字，这就是我们所需要的。 Java中的类外没有任何东西存在。 static关键字表示一个类变量，与实例变量相反，只有一个副本，并且跨越所创建的所有类的实例，这意味着可以在任何点上跨所有实例更改和访问其值

如果你需要一个可以在范围之外访问的全局变量，那么这就是你需要的变量，但是它的范围只存在于类所在的位置，而且都是。

Answer 9

在Java中没有真正的全局变量。每个静态变量都必须属于某个类（如System.out），但是当你确定它将进入哪个类时，你可以从同一个类加载器加载的所有地方引用它。

请注意，更新时应始终保护静态变量，以避免竞争条件。

Answer 10

public class GlobalClass {
     public static int x = 37;
     public static String s = "aaa";
}

这样您就可以使用GlobalClass.x和GlobalClass.s

访问它们

Answer 11

如果需要更新全局属性，则可以将简单的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 12

创建一个独立的文件，例如。 Example.java使用第一个解决方案，很好。您也可以在应用内执行此操作，例如全局变量对您当前的应用程序是特殊的，等等：

在开头创建一个类并在其中声明变量：

class Globals {
  static int month_number;
  static String month_name;
}

然后，您可以从应用中的任何位置访问这些变量 - 将它们用作'Globals.month_number'等等。

Answer 13

非常简单：

class UseOfGlobal
{
private static int a;
private static int b;
}

但是在可能的地方在方法块中定义局部变量总是很好的。

Answer 14

Java中没有全局变量，但是有公共字段的全局类。您可以使用java 5的静态导入功能使其看起来几乎像全局变量。

Answer 15

正如你可能从答案中猜到的那样，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 16

public class GlobalImpl {   

 public static int global = 5;

}

你可以随时随地打电话：

GlobalImpl.global // 5

Answer 17

通常全局变量（我假设你将它与C，Cpp进行比较）定义为public static final

像

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

ENUM在这种情况下也很有用：

例如Calendar.JANUARY）

Answer 18

了解问题

我认为全局变量的限定条件是可以在代码中的任何位置访问和更改该变量，而无需关心静态/实例调用或将任何引用从一个类传递给另一个类。

通常，如果您有A类

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

并希望访问和更新B类中的myvar，

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

现在，您可以通过以下任何位置获取全局唯一实例：

Globals globals = Globals.getInstance();
// and read and write to myVar with the getter and setter like 
int myVar = globals.getMyVar();
global.setMyVar(3);

Answer 19

面向对象程序设计是在理解变量的范围与封装那些变量的类对象紧密排斥的基础上构建的。

创建“全局变量”的问题在于它不是Java的行业标准。它不是行业标准，因为它允许多个类处理异步的数据，如果您运行的是多线程应用程序，则在线程安全性方面会变得更加复杂和危险。 various other reasons为何使用全局变量无效，但如果要避免这种情况，建议您使用 Aspect-Oriented Programming 。

面向方面的编程通过将父类通过“建议”（advices）来负责范围，从而消除了此问题，该建议在没有实际修改的情况下向代码添加了其他行为。它提供了解决交叉问题或全局变量使用的解决方案。

Spring是一个利用AOP的Java框架，虽然传统上用于Web应用程序，但该核心应用程序可以在整个Java框架（包括8.0）中通用。这可能是您想要探索的方向。

Answer 20

要允许对另一个类的静态成员进行非限定访问，您还可以进行静态导入：

import static my.package.GlobalConstants;

现在，而不是print(GlobalConstants.MY_PASSWORD);
您可以直接使用常量：print(MY_PASSWORD);

请参阅 What does the "static" modifier after "import" mean? 来决定。

考虑 Evan Lévesque 关于携带常量的接口的回答。

Answer 21

如果没有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 22

按照这个概念，全局变量（也称为实例变量）是类级别变量，即它们在类中定义，但在外部方法中定义。为了使它们完全可用并直接使用它们，请提供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

此外，在实例变量之前使用static关键字使我们不能一次又一次地为相同的变量指定数据类型。只需直接编写变量即可。

Answer 23

通常，Java没有任何全局变量。除局部变量外，所有变量都在程序中定义的任何类的范围内。我们可以使用静态变量来获得全局变量的范围。

Answer 24

// 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

Answer 25

要定义全局变量，您可以使用静态关键字

public final class Tools {
  public static int a;
  public static int b;
}

现在您可以通过调用

从任意位置访问a和b

Tools.a;
Tools.b;

Yoy是对的...特别是在J2ME ... 您可以通过放入MidLet构造函数来避免NullPointerException （proggy initialization）这行代码：

new Tools();

这可确保在任何指令之前分配工具使用它。

就是这样！

Java中的全局变量

25 个答案:

了解问题

解决方案