The static keyword in Java is used to create members that belong to the class rather than individual objects. It can be applied to variables, methods, blocks, and nested classes.
In this article, we will understand what the static keyword means, why it is used, and how static variables, methods, blocks, and classes work with simple examples.

Table of Contents

---

1. What is the static Keyword in Java?

The static keyword in Java is used to define members that belong to the class itself instead of individual objects. This means a static member can generally be accessed without creating an object of the class.

For example:

class Student {
    static String school = "ABC School";
}

Here, school is a static variable. It is associated with the Student class, so all Student objects share the same school value.
The static keyword can be used with:

1. Variables: Creates a single shared variable for all objects of a class.
2. Methods: Allows a method to be called using the class name without creating an object.
3. Blocks: Executes a block of code when the class is loaded.
4. Nested classes: Allows a class to be associated with the outer class rather than its objects.
5. In short, static is mainly used when a member should be shared across all objects or accessed at the class level.

2. Why is the static Keyword Used in Java?

The static keyword is useful when a value or behavior needs to be associated with the class rather than with individual objects. It can also help avoid unnecessary object creation.
Some common reasons for using static are:

1. To share data: A static variable is shared by all objects of a class, so only one copy of the variable is maintained.
2. To call methods without objects: Static methods can be called directly using the class name.
3. To store class-level information: Values that are common to every object, such as a company name or school name, can be declared static.
4. To run code when a class is loaded: Static blocks can be used to perform initialization before the class is used.
5. To organize utility methods: Methods that do not depend on object-specific data, such as mathematical or conversion operations, can be declared static.

For example:

class Employee {
    static String company = "TechCorp";
    static void displayCompany() {
        System.out.println(company);
    }
}
class Main {
    public static void main(String[] args) {
        Employee.displayCompany();
    }
}

Here, displayCompany() is called using the class name, so there is no need to create an Employee object.
In short, static is used when a member should be shared or accessed at the class level rather than being tied to a particular object.

3. Static Variables in Java

A static variable is a variable declared using the static keyword. Unlike instance variables, which have a separate copy for every object, a static variable has one shared copy for the entire class.
Syntax

static dataType variableName;

Example:

class Student {
    int rollNo;
    static String school = "ABC School";
    
    Student(int rollNo) {
        this.rollNo = rollNo;
    }
}

Here, rollNo is an instance variable, so every student can have a different value. However, school is static, so all Student objects share the same value.
You can access a static variable using the class name:

System.out.println(Student.school);

Why Use Static Variables?
Static variables are useful when a value is common to all objects of a class. For example, a company name can be shared by all employees, while an employee's ID would remain specific to each object.

In short, static variables are used to store class-level data that should be shared among all objects.

4. Static Methods in Java

A static method is a method declared using the static keyword. It belongs to the class rather than to individual objects, so it can be called without creating an object of the class.
Syntax:

static returnType methodName() {
    // method body
}

Example:

class Calculator {
    static int square(int num) {
        return num * num;
    }
}
class Main {
    public static void main(String[] args) {
        int result = Calculator.square(5);
        System.out.println(result);
    }
}

Here, square() is a static method, so it can be called directly using the class name:

Calculator.square(5);

There is no need to create a Calculator object.

Important Rules of Static Methods:

• A static method can directly access static variables and other static methods.
• A static method cannot directly access instance variables or instance methods because they belong to objects.
• Static methods cannot directly use the this keyword because this refers to the current object.

For example:

class Student {
    int age = 20;
    static String school = "ABC School";
    static void display() {
        System.out.println(school); // Valid
        // System.out.println(age); // Error
    }
}

Here, school can be accessed because it is static, while age cannot be accessed directly from the static method because it belongs to an object.

In short, static methods are useful for operations that do not depend on the data of a particular object.

5. Static Blocks in Java

A static block is a block of code declared using the static keyword. It is mainly used to initialize static variables or perform tasks that need to be completed when a class is loaded.
Syntax:

static {
    // code to be executed
}

A static block is executed once when the class is loaded into memory, before the main() method runs.

Example:

class Student {
    static String school;
    static {
        school = "ABC School";
        System.out.println("Static block executed");
    }
    public static void main(String[] args) {
        System.out.println(school);
    }
}

Output:

Static block executed
ABC School

Here, the static block initializes the school variable before the main() method uses it.

Why Use Static Blocks?
Static blocks are commonly used when:

1. A static variable requires complex initialization.
2. Some setup needs to happen when the class is loaded.
3. Multiple statements are required to initialize static data.

A class can also have multiple static blocks, and they are executed in the order in which they appear in the class.
In short, static blocks are used for class-level initialization that should run once when the class is loaded.

6. Static Keyword with Classes

The static keyword can also be used with nested classes in Java. A static nested class is a class declared inside another class using the static keyword.
Example

class Outer {
    static class Inner {
        void display() {
            System.out.println("This is a static nested class.");
        }
    }
}
class Main {
    public static void main(String[] args) {
        Outer.Inner obj = new Outer.Inner();
        obj.display();
    }
}

Here, Inner is a static nested class inside Outer. It can be accessed using the outer class name without creating an object of Outer.

Static Nested Class vs Inner Class
A static nested class is different from a regular inner class:

• A static nested class does not require an object of the outer class.
• A non-static inner class requires an object of the outer class.
• A static nested class can directly access only the static members of its outer class.

Static nested classes are useful when a class is closely related to another class but does not need access to the outer class's object-specific data.
In short, using static with a nested class associates it with the outer class rather than with an instance of the outer class.

7. Static vs Non-Static Members

The main difference between static and non-static members is what they belong to. Static members belong to the class, while non-static members belong to individual objects.

Feature	Static Members	Non-Static Members
Belonging	A static member belongs to the class itself.	A non-Static Member belongs to an Individual object.
Copies	A static member has one shared copy for the class.	Each object has its own copy of a non-static member.
Access	A static member can generally be accessed using a class name.	A non-static member is accessed through an object.
Object Creation	A static member can generally be used without creating an object.	An object usually needs to be created before a non-static member can be accessed.
Access to Members	A static method can directly access other static members.	A non-static method can directly access both static and non-static members.
this Keyword	A static method cannot directly use the this keyword.	A non-static method can use the this keyword to refer to the current object.

Example:

class Student {
    String name;
    static String school = "ABC School";
    void displayName() {
        System.out.println(name);
    }
    static void displaySchool() {
        System.out.println(school);
    }
}
class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Rahul";

        s1.displayName();
        Student.displaySchool();
    }
}

Here, name is non-static, so each Student object can have a different name. In contrast, school is static, so the same value is shared by all students.
In short, use static members for class-level data or behavior, and non-static members when the data or behavior should be specific to each object.

8. Static Keyword vs this Keyword

The static and this keywords serve different purposes in Java. The static keyword refers to class-level members, while the this keyword refers to the current object.

Feature	static Keyword	this Keyword
Purpose	The static keyword is used to define members that belong to the class.	The this keyword is used to refer to the current object.
Used With	The static keyword can be used with variables, methods, blocks, and nested classes.	The this keyword is mainly used with instance variables, methods, and constructors.
Object Requirement	Static members can generally be accessed without creating an object.	The this keyword can be used only in the context of an object.
Static Methods	A static method can be accessed using the class name.	The this keyword cannot be used directly inside a static method.
Main Purpose	It is used to represent class-level data or behavior.	It is used to refer to or work with the current object's data and behavior.

Example:

class Student {
    String name;
    static String school = "ABC School";
    Student(String name) {
        this.name = name;
    }
    static void displaySchool() {
        System.out.println(school);
    }
}

Here, school is static because it is shared by all students, while this.name refers to the name belonging to the current Student object.
In short, static works at the class level, whereas this works at the object level.

9. Common Mistakes and Best Practices

Although the static keyword is useful, using it incorrectly can make code harder to maintain. Here are some common mistakes and best practices to keep in mind.

1. Using static for object-specific data: Variables that can have different values for different objects should not be declared static.
2. Trying to access non-static members directly from static methods: A static method cannot directly access instance variables or instance methods.
3. Overusing static variables: Using too many shared variables can make code difficult to understand and maintain.
4. Using static when object behavior is needed: Methods that depend on an object's state should generally be non-static.
5. Confusing static nested classes with inner classes: A static nested class does not have direct access to instance members of its outer class.

Best Practices:

1. Use static when a member logically belongs to the class rather than individual objects.
2. Use static methods for operations that do not depend on object-specific data.
3. Keep shared static variables limited to values that genuinely need to be shared.
4. Prefer constants to be declared using static final when their value should remain unchanged.
5. Avoid making methods static simply to avoid creating objects when the method logically belongs to an object.

Using static appropriately helps keep Java programs organized and prevents unnecessary object creation.

10. Conclusion

The static keyword in Java is used to define members that belong to the class rather than individual objects. It can be applied to variables, methods, blocks, and nested classes.
Understanding when to use static and non-static members helps you write Java programs that are more organized, efficient, and easier to maintain.

11. Frequently Asked Questions

1. What is the static keyword in Java?

The static keyword is used to define members that belong to the class rather than to individual objects.

2. Can a static method access non-static variables?

No, a static method cannot directly access non-static variables because they belong to objects.

3. Can we access a static member without creating an object?

Yes, static members can generally be accessed using the class name without creating an object.

4. What is a static variable in Java?

A static variable is a class-level variable that has one shared copy for all objects of the class.

5. Can we use this inside a static method?

No, the this keyword cannot be used directly inside a static method because this refers to the current object.