Java – Difference Between Static and Non-Static

Java, one of the most popular programming languages, uses the static keyword to modify various elements, such as methods, variables, nested classes, and initialization blocks. Understanding the difference between static and non-static components is crucial for writing efficient and maintainable code. In this article, we will delve into the core differences between static and non-static elements in Java, supplemented with examples.

1. Basic Concept

• Static: Elements declared as static belong to the class itself, rather than any specific instance. They are initialized only once, when the class is loaded.
• Non-Static: Also called instance members, these belong to individual instances of a class. Every time a new instance (or object) is created, a separate copy of these members is made for that instance.

2. Memory Allocation

• Static: Memory for static members is allocated once and remains for the entire lifetime of the application.
• Non-Static: Memory for instance members is allocated every time an object is created and is reclaimed when the object is garbage collected.

3. Accessibility

• Static: Static members can be accessed directly by the class name, without the need for creating an object.
• Non-Static: Non-static members can only be accessed via instances (objects) of the class.

4. Use Cases

• Static: Suitable for values that should remain consistent across all instances, such as constants or utility functions.
• Non-Static: Suitable for values specific to an instance, like properties or behaviors of individual objects.

Static Member Example

public class MathUtil {
    public static final double PI = 3.14159;  // static constant

    public static double square(double num) { // static method
        return num * num;
    }
}
// Accessing static member without creating an object
double area = MathUtil.PI * 5 * 5;
double squaredValue = MathUtil.square(5);

Explanation:

1. We’ve defined a class named MathUtil.
2. Inside this class, there’s a static constant named PI. Being static means that this value belongs to the class and not any specific instance. All instances of MathUtil (if we were to create any) would share the same value of PI.
3. We also have a static method named square which takes a double value and returns its square. This method is also bound to the class and can be directly accessed without creating an instance.
4. In the external usage (outside the class), we can see that the PI constant and the square method are accessed using the class name MathUtil, not an object. This is the power of static members: no need for object instantiation for access.

Non-Static Members Example:

public class Circle {
    private double radius;  // instance variable

    public Circle(double r) {  // constructor
        this.radius = r;
    }

    public double getArea() { // instance method
        return Math.PI * radius * radius;
    }
}
// Accessing non-static member via an object
Circle circle = new Circle(5);
double area = circle.getArea();

Explanation:

1. The class Circle represents the geometric shape with a property called radius. This property is an instance variable. It means each Circle object can have its own unique value for radius.
2. The Circle class has a constructor which allows us to create instances of the class while setting the value for radius.
3. The getArea method calculates the area of the circle using its radius. This method is bound to instances of the class (i.e., individual objects), so each circle’s area is calculated based on its specific radius.
4. Outside the class, to access the getArea method, we first need to create an instance of the Circle class (here, a circle with a radius of 5). We then call the getArea method on this instance (object) to get the area specific to that circle.

The main distinction between the two examples is the need (or lack thereof) to instantiate objects. With the MathUtil class, we could directly utilize its members without any instantiation. In contrast, to utilize the members of the Circle class, we first had to create a Circle object. This exemplifies the core difference between static and non-static members in Java.

5. Restrictions

Static methods:

• Cannot access non-static instance variables or methods directly.
• Cannot use this or super keywords because they don’t refer to any instance.

Non-static methods:

• Can access both static and non-static members.

6. Initialization

• Static: Static initialization blocks are used to initialize static members. They run once when the class is loaded.
• Non-Static: Instance initialization blocks are used to initialize non-static members. They run every time an object is created.

public class Sample {
    static {
        // static initialization block
        System.out.println("Static block executed.");
    }

    {
        // instance initialization block
        System.out.println("Instance block executed.");
    }

    public Sample() {
        System.out.println("Constructor executed.");
    }

    public static void main(String[] args) {
        Sample obj1 = new Sample();  // Outputs Static > Instance > Constructor
        Sample obj2 = new Sample();  // Outputs only Instance > Constructor
    }
}

Conclusion

In Java, the distinction between static and non-static members is foundational. While static members maintain a class-level scope, non-static members have an instance-level scope. A comprehensive understanding of these concepts is essential for anyone looking to master Java programming. Remember to make judicious use of both, depending on the context and requirements of your application.