What do you mean by static modifier in java?

Answer 1

The static keyword associated with a method or a variable in java specifies that the entity belongs to the class and not any object instance of the same.

Static Methods

Static keyword when used with a method, specifies that this method belongs to the class and not a particular instance of the class (a.k.a object of the class)

Ex:

public class StaticTest {

public static String getAuthorName() {

return "Anand";

}

}

Here getAuthorName is the static method and it can be accessed without instantiating an object of the class StaticTest. You can access this method as:

String authorName = StaticTest.getAuthorName();

Static Variables

The static modifier tells the system that this particular variable belongs to the class and does not belong to any specific instance of the same. The class will contain only one instance of the static variable irrespective of how many objects of the class you create.

Answer 2

The static keyword in Java can be applied to member variables, methods, and nested classes.

When applied to member variables, it means that the static variable is shared among all instances of the class. The classic example of this uses a Point class...

Example:

public class Point {

// Coordinates - not static, thus not shared among instances of Point

public int x;

public int y;

// Keeps track of the number of Point objects created.

// Since it is static, all Point objects share this variable.

public static int numPoints = 0;

public Point(int x, int y) {

this.x = x;

this.y = y;

// Increment numPoints to tell anyone who cares that we have another

// instance of this class.

++numPoints;

}

}

When applied to methods, the static keyword means that the specified method of the object can be accessed directly, without the need for an instance of that object. Note that when implementing a static method, you cannot reference any instance variables of the class from within the static method.

Example:

// String.valueOf is a static method which converts the given object to a String object.

// Note that we don't need an instance of a String, we can reference it directly.

String s = String.valueOf(12345);

// String.substring is not a static method, so we need an instance of a String in order

// to call this method. In our case, we used the instance s.

s = s.substring(1);

When applied to nested classes (that is, classes declared within other classes), the static keyword tells Java that this nested class cannot access instance variables of the enclosing class. Basically, it's treated as if it were a top-level class.