Static Variables

Static variables, also known as class variables, can be accessed using the syntax ClassName.variableName. While it's possible to access them through an object reference (e.g., objectName.variableName), this approach is not recommended as it can be misleading.

public class Person {
    public static void main(String[] args) {
        // Accessing static variable via class name
        Person.name = "John";
        
        // Accessing instance variable via object reference
        Person p1 = new Person();
        p1.age = 25;
        
        // Recommended: access static via class name
        System.out.println(Person.name + " " + p1.age);
        
        Person p2 = new Person();
        System.out.println(p2.name);
    }
}

Static Methods vs Instance Methods

Static Methods (Class Methods): Methods decorated with the static keyword belong to the class rather than any instance. They are loaded when the class is loaded, meaning they can be invoked directly using the class name with out creating an object.

Instance Methods (Member Methods): Non-static methods require an object instance to be called becuase they may access instance variables, wich only exist after an object is created.

public class Student {
    double grade;
    
    // Static method - invoke via ClassName.methodName()
    public static void displayGreeting(){
        System.out.println("Welcome...");
        System.out.println("Welcome...");
    }
    
    // Instance method - invoke via objectReference.methodName()
    public void introduce(){
        System.out.println("My grade: " + grade);
    }
    
    public void process(){
        System.out.println("Processing..........");
        this.introduce();
        introduce();   // 'this' is implicit
    }
}

Utility Classes

One of the most common use cases for static members is creating utility classes. These classes provide helper functions that don't require object state.

public class CodeGenerator {
    // Prevent instantiation by making constructor private
    private CodeGenerator(){}
    
    // All methods are static for easy access
    public static String createVerificationCode(int length){
        String characters = "0123456789";
        StringBuilder result = new StringBuilder();
        Random generator = new Random();
        for (int i = 0; i < length; i++) {
            int index = generator.nextInt(characters.length());
            char digit = characters.charAt(index);
            result.append(digit);
        }
        return result.toString();
    }
}

Static Blocks vs Instance Blocks

Static Initialization Block: Executes once when the class is loaded, running after static variables are initialized.

Instance Initialization Block: Executes every time an object is created, before the constructor runs.

public class Employee {
    static String employeeName = "Alice";
    static String department = "HR";
    
    static {
        // Executes after static variables
        System.out.println("Static initializer running~~~~");
        department = "Engineering";
    }
}

public class TestMain {
    public static void main(String[] args) {
        System.out.println(Employee.employeeName);
        System.out.println(Employee.department);
        Employee emp1 = new Employee();
        Employee emp2 = new Employee();
        Employee emp3 = new Employee();
    }
}

The console output demonstrates that the static block runs only once during class loading, while instance blocks would execute for each object creation.