Global Variables in Java

Global variables in Java

To define Global Variable you can make use of static Keyword

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

now you can access a and b from anywhere
by calling

Example.a;

Example.b;

How to initialize global variable in method

If you want to make some variable global then you would need to declare the variable outside the method. In java, you cannot declare static variables inside method (even if it is static) because inside method all variables are local variables that has no existence outside this method thats why they can't be static.

import java.util.*;

public class GlobalVariable{
    static int b;
    public static void main(String...args){
        GlobalVariable.compare(1);
        System.out.println(b);
    }

    static void compare(int a){
        Scanner sc = new Scanner(System.in);
        b = sc.nextInt();
    }
}

Java - When a global variable is declared and initialized with a value, the what happens while object creation?

what you said is not quite how memory allocation works.

class A{

int a = 10;

}

in the above example you created a class. the members in the class are only created and assigned their values after their objects are created unless the the members are declared as static. hence the variable 'a' is assigned the value 10 after the construction of the object 'a' of class A in the second example you posted. If you still don't understand, then run this code:

class A{
int a = 10;
public static void main(String args[]){
A a = new A();
A b = new A();
b.a += 10;
System.out.println(a.a);
System.out.println(b.a);
}
}

if the variable a was assigned before creation of object, then when object b modifies it, the variable printed would change. But if you run this the out put will be:

10
20

which means that the variables only got assigned after object creation. I hope this clears your doubt. Also another tip for you, Static variables cannot be modified.

Is there a way to make global variables in java?

public class ClassName {
    public static String varName = "this can be used globally;"
}

Now can be referenced globally by

ClassName.varName

Note: public is important since a private will not be accessible from the outside the class.

Java global variables - What is the convention to declare?

There are several rules:

Variable names are case-sensitive. A variable's name can be any legal identifier — an unlimited-length sequence of Unicode letters and digits, beginning with a letter, the dollar sign "$", or the underscore character "". The convention, however, is to always begin your variable names with a letter, not "$" or "". Additionally, the dollar sign character, by convention, is never used at all. You may find some situations where auto-generated names will contain the dollar sign, but your variable names should always avoid using it. A similar convention exists for the underscore character; while it's technically legal to begin your variable's name with "_", this practice is discouraged. White space is not permitted.
Subsequent characters may be letters, digits, dollar signs, or underscore characters. Conventions (and common sense) apply to this rule as well. When choosing a name for your variables, use full words instead of cryptic abbreviations. Doing so will make your code easier to read and understand. In many cases it will also make your code self-documenting; fields named cadence, speed, and gear, for example, are much more intuitive than abbreviated versions, such as s, c, and g. Also keep in mind that the name you choose must not be a keyword or reserved word.
If the name you choose consists of only one word, spell that word in all lowercase letters. If it consists of more than one word, capitalize the first letter of each subsequent word. The names gearRatio and currentGear are prime examples of this convention. If your variable stores a constant value, such as static final int NUM_GEARS = 6, the convention changes slightly, capitalizing every letter and separating subsequent words with the underscore character. By convention, the underscore character is never used elsewhere.

From here
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/variables.html

If I read these rules right, valid names(by naming convention) will be:

private Object largerVariable;
private Object LARGER_VARIABLE;

How do i make a global variable in Java

The short answer is that you almost certainly shouldn't be doing it.

But if you really want to, then you can declare your variables as static. If you move this

int i = 0;
int t = 0;
int st = 0;
int h = 0;

to the beginning, just after the class declaration, and change to

static int i = 0;
static int t = 0;
static int st = 0;
static int h = 0;

then you'll find you can access them as globals, at least from inside this package. If you declare them public too, you'll be able to get to them from anywhere.

But, really, you shouldn't do it like this at all. Have your public static void main() method create an instance of the class (Main m = new Main()) and then invoke some instance method on m. That instance method will be able to access non-static (instance) fields.

Whenever you feel the need for a global, ask yourself whether it's an indication that your code isn't structured in the right way. Most of the time (not quite all of the time) when you think you want a global, you don't really. It will just make the structural problem worse.

Creating global variables - Java

This happens because your Matching class is located inside another class called testingProgram, and is not static.

Java allows static fields inside an inner class only when the inner class itself is static. You can fix this problem in several ways:

By making Matching a static inner class,
By making Matching a top-level class, or
By making static int match final, i.e. final static int match

What is the best way to implement global variables to whole code in java

If you create a Resources class with public static members, you can access them by referencing them like, for example, Resources.myGlobalData, anywhere you import that class.

So, (untested but should be accurate)

public class Resources {
    public static int count = 1; // default initialization to 1
}
public class Main {
    public static void main(String[] args) {
        Resources.count++;
        System.out.println(Resources.count); // prints 2
    }
}

However, I would urge you to reconsider your design, as anytime you have mutable global state, you're asking for bugs when the global state is (or isn't) changed.

If you actually want to generate compile-time constants like C-style #DEFINE preprocessor macros, you can use public static final fields. These do not carry the problems of global state because the final keyword makes them immutable. (Most compilers will inline the value at compile-time, just like a #DEFINE is implemented in C-style languages.)

Global Variables in Java