Global Variables in Java

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.

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

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

Another way is to create an interface like this:

public interface GlobalConstants
{
  String name = "Chilly Billy";
  String address = "10 Chicken head Lane";
}

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

public class GlobalImpl implements GlobalConstants
{
  public GlobalImpl()
  {
     System.out.println(name);
  }
}

You are better off using dependency injection:

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

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

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.

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

Truly speaking there is not a concept of "GLOBAL" in a java OO program

Nevertheless there is some truth behind your question because there will be some cases where you want to run a method at any part of the program. For example---random() method in Phrase-O-Matic app;it is a method should be callable from anywhere of a program.

So in order to satisfy the things like Above "We need to have Global-like variables and methods"

TO DECLARE A VARIABLE AS GLOBAL.

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

TO DECLARE A METHOD AS GLOBAL.

 1. Mark the method as public static While declaring.

Because I declared global variables and method as static you can call them anywhere you wish by simply with the help of following code

ClassName.X

NOTE: X can be either method name or variable name as per the requirement and ClassName is the name of the class in which you declared them.

There is no global variable in Java

Nevertheless, what we do have is a static keyword and that is all we need. Nothing exists outside of class in Java. The static 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.

Nothing should be global, except for constants.

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

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

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

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!

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.

Understanding the problem

I consider the qualification of global variable as a variable that could be accessed and changed anywhere in the code without caring about static/instance call or passing any reference from one class to another.

Usually if you have class 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;
    }
}

and want to access and update myvar in a class B,

public class B{

    private A a;

    public void passA(A a){
        this.a = a;
    }

    public void changeMyVar(int newVar){
        a.setMyvar(newVar);
    }
}

you will need to have a reference of an instance of the class A and update the value in the class B like this:

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