Static Keyword in Java

The static keyword in Java is used for memory management and to manage class-level methods and variables. It can be applied to variables, methods, blocks, and nested classes. When a method or variable is declared as static, it belongs to the class rather than instances of the class. This means you can access static members without creating an object of the class.

1. Static Variables in Java

A static variable is shared among all instances of a class. It is initialized only once, at the start of the execution. Static variables are also known as class variables because they are common to all objects of the class.

Syntax of Static Variable

    class ClassName {
        static dataType variableName; // static variable
    }

Example 1: Static Variable

In this example, we declare a static variable count that tracks how many objects of the class Counter are created.

    class Counter {
        static int count = 0; // Static variable
    
        Counter() {
            count++; // Increment count for each object created
        }
    
        static void displayCount() {
            System.out.println("Count: " + count); // Static method to access static variable
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Counter c1 = new Counter(); // Object 1 created
            Counter c2 = new Counter(); // Object 2 created
    
            Counter.displayCount(); // Accessing static method to display count
        }
    }

Output:

    Count: 2

Explanation:

  • The static variable count is shared by both c1 and c2.
  • Every time a new Counter object is created, the constructor increments the static variable count.
  • The static method displayCount() is used to access the static variable count and display its value.

2. Static Methods in Java

A static method is a method that belongs to the class rather than any object. Static methods can access and modify static variables of the class, but they cannot access instance variables or methods directly. To access instance variables or methods, an object of the class must be created.

Syntax of Static Method

    class ClassName {
        static returnType methodName() {
            // Method body
        }
    }

Example 2: Static Method

In this example, we demonstrate how a static method can be used to calculate the area of a rectangle. The static method calculateArea does not require an instance of the class.

    class Rectangle {
        static double calculateArea(double length, double width) {
            return length * width; // Static method
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            double area = Rectangle.calculateArea(5.0, 4.0); // Calling static method
            System.out.println("Area: " + area);
        }
    }

Output:

    Area: 20.0

Explanation:

  • The method calculateArea is static, so it can be called without creating an instance of the Rectangle class.
  • The static method directly calculates the area of the rectangle by multiplying the given length and width.

3. Accessing Static Members

Static members (variables or methods) can be accessed using either the class name or an object reference. However, it is recommended to access static members through the class name to avoid confusion.

Example 3: Accessing Static Members

In this example, we demonstrate how to access static variables and methods using both the class name and object references.

    class Car {
        static int wheels = 4; // Static variable
    
        static void displayWheels() {
            System.out.println("Number of wheels: " + wheels); // Static method
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            // Accessing static variable and method using class name
            System.out.println("Wheels using class name: " + Car.wheels);
            Car.displayWheels();
    
            // Accessing static variable and method using object reference
            Car car1 = new Car();
            System.out.println("Wheels using object reference: " + car1.wheels);
            car1.displayWheels();
        }
    }

Output:

    Wheels using class name: 4
    Number of wheels: 4
    Wheels using object reference: 4
    Number of wheels: 4

Explanation:

  • Both static variables and methods can be accessed using the class name (e.g., Car.wheels and Car.displayWheels()).
  • Static members can also be accessed using an object reference, but it is not recommended because static members are related to the class, not individual instances.

4. Static Block in Java

A static block is used to initialize static variables. It is executed only once when the class is loaded into memory, making it useful for one-time setup tasks.

Syntax of Static Block

    class ClassName {
        static {
            // Static block
        }
    }

Example 4: Static Block

In this example, we use a static block to initialize the static variable message when the class is loaded.

    class MyClass {
        static String message;
    
        static {
            message = "This is a static block example."; // Static block
        }
    
        static void displayMessage() {
            System.out.println(message); // Static method
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            MyClass.displayMessage(); // Calling static method
        }
    }

Output:

    This is a static block example.

Explanation:

  • The static block initializes the static variable message when the class is loaded into memory.
  • The static method displayMessage() accesses and displays the static variable.

5. Conclusion

The static keyword in Java is an important concept that allows you to define class-level variables and methods. Static variables are shared among all instances of a class, while static methods can be called without creating an instance of the class. Static blocks are useful for initializing static variables. The static keyword helps improve memory management and makes code more efficient.




Advertisement