In this article, I will help you understand the differences between the static and non-static variables, static and non-static methods in Java. You know, most beginners have confusions with this matter and one faces this error at least one time:

non-static variable number cannot be referenced from a static context

Do you see this message looks familiar?

If you are unsure about the static and non-static, read on and I will clear your doubts in few minutes. In addition, I’ll share something interesting which you may not know before.

Generally, static is a modifier applying for member variables and methods.

 

1. What is a non-static variable?

A non-static variable is a regular one. It’s better to understand the concept by looking at some examples. Given the following class:

public class A {
	public int x;
}

You know, we can create as many instances of the class A as we want. For example:

A a1 = new A();
a1.x = 1;

A a2 = new A();
a2.x = 2;

System.out.println("a1.x = " + a1.x);
System.out.println("a2.x = " + a2.x);

Here, x is a non-static variable, and each object of the class A has its own copy of x, thus the following output:

a1.x = 1
a2.x = 2

To remember, a non-static variable belongs to an instance (object) of a class. Each object has its own copy of the variable.

Now, let’s see how difference is the static variable.

 

2. What is a static variable?

A static variable is modified by the static modifier. Let’s modify the class A above by making the x variable static:

public class A {
	public static int x;
}

Note that the static modifier is used before the variable type. And here’s the same test code as above:

A a1 = new A();
a1.x = 1;

A a2 = new A();
a2.x = 2;

System.out.println("a1.x = " + a1.x);
System.out.println("a2.x = " + a2.x);

But the output is different:

a1.x = 2
a2.x = 2

Oh, why do we get the same value of x? It’s because a static variable is shared among all instances of a class. In other words, a static variable is unique: there’s only one copy which is shared by all objects.

Hence there’s no need of creating an object to access the static variable. We can write:

A.x = 3;
System.out.println("A.x = " + A.x);

Output:

A.x = 3

NOTE: We use the class name to access the static members without creating an object.

 

3. Non-static method

A non-static method is just a regular one. For example:

public class Dog {
	public void bark() {
		System.out.println("Go Go!");
	}
}

Similar to non-static variable, we can only invoke a non-static method via an instance of the class. For example:

Dog dog = new Dog();
dog.bark();

 

4. Static method

Similar to static variable, a static method is modified by the static modifier. Here’s an example:

public class Math {
	public static int add(int a, int b) {
		return a + b;
	}
}

A static method is shared by all instances of a class, so there’s no need of creating a specific object to invoke the static method. For example:

int sum = Math.add(7, 8);
System.out.println("sum = " + sum);

Output:

sum = 15

 

5. Why do we get the error: non-static variable number cannot be referenced from a static context?

How many times did you get this error? I bet you faced it several times in your life, right?

Until now I think you know the reason. Let me explain.

When we are trying to access a non-static variable or a non-static method from a static method, we’ll get such error.

Let’s see the following example:

public class Test {
	public int number;

	public static void main(String[] args) {
		number = 5;
	}
}

Here, main() is a static method and number is a non-static variable. The number variable must belong to an instance, whereas the main() method does not, hence the Java compiler complain:

non-static variable number cannot be referenced from a static context

That’s simple! Got it?

On the contrary, we can always access static members from anywhere. For example:

public class B {
	static int z;

	public void bar() {
		z = 1000; // Okay, fine!
	}
}

 

So to remember:

- Static members can be accessed from anywhere.

- Non-static members cannot be accessed from static context like in a method.

 

* Is there static class?

No, there is no static class. But there’s inner static class.

 

* Static members can be inherited?

Yes, of course. A subclass inherits all accessible static members from its super class.

 

* Static methods can be overridden?

No. If we have a method with the same signature in the subclass, then that method hides the one in the super class, not overridden. Here’s an example:

public class Parent {
	protected void foo() {
		System.out.println("Parent->foo");
	}
}

public class Child extends Parent {
	public static void foo() {
		System.out.println("Child->foo");
	}
}

Here’s the static foo() method in the Child class hides the one in the Parent class.

 

6. When do we use static and non-static members?

Generally, non-static members are preferred. As in OOP we create objects with states and behaviors. And different objects have different states, so we should use non-static members if they are specific to each object.

Use static variables if they should be shared among all objects, e.g. a variable to keep track the number of instances, a constant, etc.

Use static methods if they do not depend on states of any objects, e.g. utility methods that do calculation.

 

Related Tutorials:

• Java static keyword
• What is static method in Java?
• Java Static Nested Classes and Inner Classes

 

Other Recommended Tutorials:

• 9 Rules about Constructors in Java
• 12 Rules and Examples About Inheritance in Java
• 12 Rules of Overriding in Java You Should Know
• Java Access Modifiers Examples: public, protected, private and default
• 10 Java Core Best Practices Every Java Programmer Should Know
• Java Variables Passing Examples - Pass-by-value or Pass-by-reference?