What does the 'static' keyword do in Java?

Question

To be specific, I was trying this code:

package hello;

public class Hello
{
    Clock clock = new Clock();
    public static void main(String args[])
    {
     clock.sayTime();
    }
}

But it gave an error like 'Cannot access non-static field in static method main'. So I changed the declaration of clock to this:

static Clock clock = new Clock();

And it worked. Now my question is, what does it mean to put that keyword before the declaration? What exactly will it do/restrict in terms of what can be done to that object?

Answer 1

static members belong to the class instead of a specific instance.

It means that only one instance of a static field exists even if you create a million instances of the class or you don't create any. It will be shared by all instances.

Since static methods also do not belong to a specific instance, they can't refer to instance members (how would you know which instance Hello class you want to refer to?). static members can only refer to static members. Instance members can, of course access static members.

Side note: Of course, static members can access instance members through an object reference.

Answer 2

It means you don't have to have an instance of the class to use the method. So in your example, you could call:

Hello.main(new String[]())

directly, instead of:

Hello h = new Hello();
h.main(new String[]());

Edit

From inside a static method (one belonging only to the class) you cannot access any members which are not static, since their values depend on your instantiation of the class. So Clock, which is an instance member, would have a different value/reference for each instance of your Hello class, and therefore you could not access it from the static portion of the class.

Answer 3

It means that there is only one instance of "clock" in Hello, not one per instance of Hello. So if you were to do a "new Hello" anywhere in your code, in the first instance (without the "static"), it would make a new clock, but in the second instance, it would still use the original "clock".

Unless you needed "clock" somewhere outside of main, this would work just as well:

package hello;
public class Hello
{
    public static void main(String args[])
    {
      Clock clock=new Clock();
      clock.sayTime();    
    }
}

Answer 4

Static makes the clock member a class member instead of an instance member. Without the static keyword you would need to create an instance of the Hello class (which has a clock member variable) - e.g.

Hello hello = new Hello();
hello.clock.sayTime();

Answer 5

static methods don't use any instance variables of the class they are defined in. A very good explanation of the difference can be found on this page

Answer 6

A field can be assigned to either the class or an instance of a class. By default fields are instance variables. By using static the field becomes a class variable, thus there is one and only one clock. If you make a changes in one place, it's visible everywhere. Instance varables are changed independently of one another.

Answer 7

This discussion has so far ignored classloader considerations. Strictly speaking, Java static fields are shared between all instances of a class for a given classloader.

Answer 8

Can also think of static members not having a "this" pointer. They are shared among all instances.

Answer 9

Once again remember that there is one instance of a static per class per CLASSLOADER.

Answer 10

The static keyword in Java means that the variable or function is shared between all instances of that class as it belongs to the type, not the actual objects themselves.

So if you have a variable: private static int i = 0; and you increment it (i++) in one instance, the change will be reflected in all instances. i will now be 1 in all instances.

Static methods can be used without instantiating an object.

Answer 11

The static keyword means that something (a field, method or inner class) is related to the type rather than any particular instance of the type. So for example, one calls Math.sin(...) without any instance of the Math class, and indeed you can't create an instance of the Math class.

For more information, see the relevant bit of Sun's Java Tutorial.

---

Sidenote

Java unfortunately allows you to access static members as if they were instance members, e.g.

// Bad code!
Thread.currentThread().sleep(5000);
someOtherThread.sleep(5000);

That makes it look as if sleep is an instance method, but it's actually a static method - it always makes the current thread sleep. It's better practice to make this clear in the calling code:

// Clearer
Thread.sleep(5000);