blocks|key|1041559|text|要定义全局变量，可以使用static关键字|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1041560|public+class+Example+{
++++public+static+int+a;
++++public+static+int+b;
}|code-block|syntax|javascript|1041561|现在，您可以在任何地方通过调用|1041562|Example.a;

Example.b;|1041563|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To define Global Variable you can make use of static Keyword

<pre><code>public class Example {
 public static int a;
 public static int b;
}
</code></pre>

now you can access a and b from anywhere
by calling

<pre><code>Example.a;

Example.b;
</code></pre>

blocks|key|826851|text|你不需要。这是设计好的。即使你能做到，你也不应该这么做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|826852|也就是说，您可以在一个名为Globals的类中创建一组公共静态成员。|826853|public+class+Globals+{
+++public+static+int+globalInt+=+0;
+++///
}|code-block|syntax|javascript|826854|但是你真的不应该:)。说真的..。不要这样做。|826855|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You don't. That's by design. You shouldn't do it even if you could. 

That being said you could create a set of public static members in a class named Globals. 

<pre><code>public class Globals {
 public static int globalInt = 0;
 ///
}
</code></pre>

but you really shouldn't :). Seriously .. don't do it.

blocks|key|1041989|text|另一种方法是创建一个这样的接口：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1041990|public+interface+GlobalConstants
{
++String+name+=+"Chilly+Billy";
++String+address+=+"10+Chicken+head+Lane";
}|code-block|syntax|javascript|1041991|任何需要使用它们的类只需要实现接口：|1041992|public+class+GlobalImpl+implements+GlobalConstants
{
++public+GlobalImpl()
++{
+++++System.out.println(name);
++}
}|1041993|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another way is to create an interface like this:

<pre><code>public interface GlobalConstants
{
 String name = "Chilly Billy";
 String address = "10 Chicken head Lane";
}
</code></pre>

Any class that needs to use them only has to implement the interface:

<pre><code>public class GlobalImpl implements GlobalConstants
{
 public GlobalImpl()
 {
 System.out.println(name);
 }
}
</code></pre>

blocks|key|1041900|text|你最好使用依赖注入：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1041901|public+class+Globals+{
++++public+int+a;
++++public+int+b;
}

public+class+UsesGlobals+{
++++private+final+Globals+globals;
++++public+UsesGlobals(Globals+globals)+{
++++++++this.globals+=+globals;
++++}
}|code-block|syntax|javascript|1041902|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You are better off using dependency injection:

<pre><code>public class Globals {
 public int a;
 public int b;
}

public class UsesGlobals {
 private final Globals globals;
 public UsesGlobals(Globals globals) {
 this.globals = globals;
 }
}
</code></pre>

blocks|key|827415|text|有很多好的答案，但我想给出这个例子，因为它被认为是另一个类访问一个类的变量的更合适的方法:使用getter和setter。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827416|为什么要以这种方式使用getter和setter，而不是仅仅将变量设置为公共变量，原因如下。假设您的var将是一个全局参数，您永远不希望有人在您的程序执行过程中更改它(在您与团队一起开发代码的情况下)，类似于网站的URL。从理论上讲，这可能会改变，并且可能会在您的程序中多次使用，因此您希望使用全局变量来一次更新所有变量。但是您不希望其他人进入并更改这个变量(可能没有意识到它有多重要)。在这种情况下，您只需包含getter方法，而不包含setter方法。|827417|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;
++++}
}|code-block|syntax|javascript|827418|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Lots of good answers, but I want to give this example as it's considered the more proper way to access variables of a class by another class: using getters and setters.

The reason why you use getters and setters this way instead of just making the variable public is as follows. Lets say your var is going to be a global parameter that you NEVER want someone to change during the execution of your program (in the case when you are developing code with a team), something like maybe the URL for a website. In theory this could change and may be used many times in your program, so you want to use a global var to be able to update it all at once. But you do not want someone else to go in and change this var (possibly without realizing how important it is). In that case you simply do not include a setter method, and only include the getter method.

<pre><code>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;
 }
}
</code></pre>

blocks|key|1042316|text|Java中没有全局变量|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1042317|然而，我们所拥有的是static关键字，这就是我们所需要的。在Java中，类之外不存在任何东西。static关键字表示一个类变量，与实例变量相反，它只有一个副本，并且可以跨越创建的该类的所有实例，这意味着它的值可以在任何时候在所有实例中更改和访问。|offset|length|style|CODE|1042318|如果你需要一个可以在作用域之外访问的全局变量，那么这就是你需要的变量，但它的作用域只存在于类所在的地方，仅此而已。|1042319|entityMap^0|0|A|6|1C|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

There is no global variable in Java

Nevertheless, what we do have is a <code>static</code> keyword and that is all we need.
Nothing exists outside of class in Java. The <code>static</code> keyword represents a class variable that, contrary to instance variable, only has one copy and that transcends across all the instances of that class created, which means that its value can be changed and accessed across all instances at any point.

If you need a global variable which can be accessed beyond scopes, then this is the variable that you need, but its scope exists only where the class is, and that will be all.

blocks|key|827298|text|除了常量之外，没有任何东西应该是全局的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827299|public+class+MyMainClass+{
++++public+final+static+boolean+DEBUGMODE=true;
}|code-block|syntax|javascript|827300|将其放入您的主类中。在其他.java文件中，可通过以下方式使用它：|827301|if(MyMainClass.DEBUGMODE)+System.out.println("Some+debugging+info");|827302|确保当你将你的代码从剪辑室移到发行版中时，你移除或注释掉了这个功能。|827303|如果你有一个常用的方法，比如随机数发生器，我建议你创建一个“工具箱”包！所有的程序员都应该有一个，那么当你想在.java中使用它的时候，只要导入它就行了！|827304|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Nothing should be global, except for constants.

<pre><code>public class MyMainClass {
 public final static boolean DEBUGMODE=true;
}
</code></pre>

Put this within your main class. In other .java files, use it through:

<pre><code>if(MyMainClass.DEBUGMODE) System.out.println("Some debugging info");
</code></pre>

Make sure when you move your code off the cutting room floor and into release you remove or comment out this functionality.

If you have a workhorse method, like a randomizer, I suggest creating a "Toolbox" package! All coders should have one, then whenever you want to use it in a .java, just import it!

blocks|key|1041836|text|在Java中没有真正的全局变量。每个静态变量都必须属于某个类(如System.out)，但是当您决定它将属于哪个类时，您可以从同一类加载器加载的任何地方引用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1041837|请注意，静态变量在更新时应始终受到保护，以避免争用条件。|1041838|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

There is no such thing as a truly global variable in Java. Every static variable must belong to some class (like System.out), but when you have decided which class it will go in, you can refer to it from everywhere loaded by the same classloader.

Note that static variables should always be protected when updating to avoid race conditions.

blocks|key|826905|text|public+class+GlobalClass+{
+++++public+static+int+x+=+37;
+++++public+static+String+s+=+"aaa";
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|826906|这样，您就可以通过GlobalClass.x和GlobalClass.s访问它们|unstyled|offset|length|style|CODE|826907|entityMap^0|0|9|D|N|D|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|S|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>public class GlobalClass {
 public static int x = 37;
 public static String s = "aaa";
}
</code></pre>

This way you can access them with <code>GlobalClass.x</code> and <code>GlobalClass.s</code>

blocks|key|826960|text|public+class+GlobalImpl+{+++

+public+static+int+global+=+5;

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|826961|您可以随心所欲地呼叫：|unstyled|826962|GlobalImpl.global+//+5|826963|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>public class GlobalImpl { 

 public static int global = 5;

}
</code></pre>

you can call anywhere you want:

<pre><code>GlobalImpl.global // 5
</code></pre>

blocks|key|1042616|text|如果需要更新全局属性，可以使用一个简单的getter/setter包装类作为全局变量。下面是一个典型的例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1042617|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());
++++}
}|code-block|syntax|javascript|1042618|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you need to update global property, a simple getter/setter wrapper class can be used as global variable. A typical example is shown below.

<pre class="lang-java prettyprint-override"><code>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());
 }
}
</code></pre>

blocks|key|1041630|text|通常，全局变量(我假设您将其与C、Cpp进行比较)定义为public+static+final|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1041631|喜欢|1041632|class+GlobalConstant{
++++public+static+final+String+CODE++=+"cd";
}|code-block|syntax|javascript|1041633|ENUM在以下场景中也很有用：|1041634|例如Calendar.JANUARY)|1041635|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/6/docs/api/java/util/Calendar.html#JANUARY^0|S|J|0|0|0|0|2|G|2|G|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

Generally Global variable (I assume you are comparing it with C,Cpp) define as <code>public static final</code>

like

<pre><code>class GlobalConstant{
 public static final String CODE = "cd";
}
</code></pre>

ENUMs are also useful in such scenario :

For Example <a href="http://download.oracle.com/javase/6/docs/api/java/util/Calendar.html#JANUARY" rel="nofollow"><code>Calendar.JANUARY</code></a>)

blocks|key|1041952|text|Java中没有全局变量，但有带有公共字段的全局类。您可以使用java5的静态导入功能来使其看起来几乎像全局变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1041953|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There are no global variables in Java, but there are global classes with public fields. You can use static import feature of java 5 to make it look almost like global variables.

blocks|key|827675|text|创建一个独立的文件，例如。Example.java使用第一个解决方案，这是很好的。你也可以在应用程序中这样做，例如，如果全局变量对于当前的应用程序是特殊的，等等：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827676|在开头创建一个类，并在其中声明您的变量：|827677|class+Globals+{
++static+int+month_number;
++static+String+month_name;
}|code-block|syntax|javascript|827678|然后，你可以在你的应用程序的averywhere中访问这些变量--使用它们作为'Globals.month_number'，等等。|827679|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Creating an independent file, eg. Example.java to use the 1st solution, is just fine. You can do that also within the app, if e.g. the global variables are special to your current app, etc.:

Create a class at the beginning and declare your variables in there:

<pre><code>class Globals {
 static int month_number;
 static String month_name;
}
</code></pre>

You can then access these variables -- using them as 'Globals.month_number', etc. -- from averywhere in your app.

blocks|key|1042704|text|非常简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1042705|class+UseOfGlobal
{
private+static+int+a;
private+static+int+b;
}|code-block|syntax|javascript|1042706|但是只要有可能，在方法块中定义局部变量总是很好的。|1042707|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

very simple:
<pre><code>class UseOfGlobal
{
private static int a;
private static int b;
}
</code></pre>
but it is always good to have local variables defined inside method blocks where ever possible.

blocks|key|1042398|text|一般来说，Java没有任何全局变量。除局部变量外，所有变量都在程序中定义的任何类的范围内。我们可以使用静态变量来拥有全局变量的作用域。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1042399|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In general, Java doesn't have any global variables. Other than local variables, all variables comes under the scope of any class defined in the program.
We can have static variables to have the scope of global variables.

blocks|key|827723|text|根据概念，全局变量，也称为实例变量是类级变量，即它们在类内定义，但在方法外部定义。为了使它们完全可用并直接使用，需要提供static关键字。因此，如果我正在编写一个用于简单算术运算的程序，并且它需要一个数字对，那么两个实例变量的定义如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827724|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:+"%2Bc);+
++++}

++++static+int+sum()+{
+++++++a=20;
+++++++b=30;
+++++++return+a%2Bb;+++
++++}
}

Output:+Sum+is:+50|code-block|syntax|javascript|827725|此外，在实例变量之前使用static关键字使我们不必一次又一次地为相同的变量指定数据类型。只需直接编写变量即可。|827726|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Going by the concept, global variables, also known as instance variable are the class level variables,i.e., they are defined inside a class but outside methods. In order to make them available completely and use them directly provide the static keyword. 
So if i am writing a program for simple arithmetical operation and it requires a number pair then two instance variables are defined as such:

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

Moreover using static keyword prior to the instance variables enable us not to specify datatypes for same variables again and again. Just write the variable directly.

blocks|key|827748|text|如果没有static，这也是可能的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|827749|class+Main+{
++String+globalVar+=+"Global+Value";

++class+Class1+{
++++Class1()+{
++++++System.out.println("Class1:+"%2BglobalVar);
++++++globalVar+%2B=+"+-+changed";
++}+}
++class+Class2+{
++++Class2()+{
++++++System.out.println("Class2:+"%2BglobalVar);
++}+}

++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
*/|code-block|syntax|javascript|827750|entityMap^0|4|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

without <code>static</code> this is possible too:

<pre><code>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
*/
</code></pre>

blocks|key|1042238|text|//+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:+"+%2B+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+:+"+%2B+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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1042239|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|1042769|text|要允许对另一个类的静态成员进行非限定访问，还可以执行静态导入：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1042770|import+static+my.package.GlobalConstants;|code-block|syntax|javascript|1042771|现在，代替print(GlobalConstants.MY_PASSWORD);|offset|length|style|CODE|1042772|您可以直接使用常量：print(MY_PASSWORD);|1042773|请参阅What+does+the+"static"+modifier+after+"import"+mean?以作决定。|1042774|考虑一下Evan+Lévesque关于携带常量的接口的答案。|1042775|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/162187/what-does-the-static-modifier-after-import-mean^0|0|0|5|Z|0|A|J|0|3|1G|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@$I|19|J|1A|1|1B]]|A|$]]|$1|Q|3|R|5|6|7|1C|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

To allow an unqualified access to static members of another class, you can also do a static import:
<pre><code>import static my.package.GlobalConstants;
</code></pre>
Now, instead of <code>print(GlobalConstants.MY_PASSWORD);</code> 
you can use the Constant directly: <code>print(MY_PASSWORD);</code>
See <a href="https://stackoverflow.com/questions/162187/what-does-the-static-modifier-after-import-mean">What does the &quot;static&quot; modifier after &quot;import&quot; mean?</a> to decide about.
And consider the answer of Evan Lévesque about interfaces to carry the Constants.

blocks|key|827344|text|要定义全局变量，可以使用static关键字|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827345|public+final+class+Tools+{
++public+static+int+a;
++public+static+int+b;
}|code-block|syntax|javascript|827346|现在，您可以在任何地方通过调用|827347|Tools.a;
Tools.b;|827348|Yoy+are+right...specially+in+J2ME...你可以通过在你的MidLet构造函数中放入下面这行代码来避免NullPointerException：|827349|new+Tools();|827350|这样可以确保在使用工具的任何指令之前分配工具。|827351|就这样!|827352|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

To define Global Variable you can make use of static Keyword

<pre><code>public final class Tools {
 public static int a;
 public static int b;
}
</code></pre>

now you can access a and b from anywhere by calling

<pre><code>Tools.a;
Tools.b;
</code></pre>

Yoy are right...specially in J2ME...
 You can avoid NullPointerException by putting inside your MidLet constructor
(proggy initialization) this line of code:

<pre><code>new Tools();
</code></pre>

This ensures that Tools will be allocated before any instruction
that uses it.

That's it!

How do you define Global variables in Java ?

问Java中的全局变量
EN

回答 21

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的全局变量EN

回答 21

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的全局变量
EN