To which constructs in Java can the static modifier…

The static modifier in Java can be applied to the following constructs:

Class Fields (Static Fields):
Belong to the class itself rather than a specific instance. They are initialized when the class is loaded. Accessible via the class name (ClassName.fieldName).
```
// Example of a static field
public class MyClass {
    static int staticCounter = 0;

    public MyClass() {
        staticCounter++;
    }
}
```
Class Methods (Static Methods):
Also belong to the class. They cannot directly access non-static fields and methods because they do not have access to a specific instance. Called via the class name (ClassName.methodName()). Often used for utility functions or operations that do not depend on object state.
```
// Example of a static method
public class MyMath {
    public static int add(int a, int b) {
        return a + b;
    }
}
```

Initialization Blocks (Static Initialization Blocks):
Executed once when the class is loaded into the JVM. Used for initializing static fields that require more complex logic than simple assignment.

// Example of a static initialization block
public class MyClass {
    static {
        // Logic for initializing static fields
        System.out.println("Static block executed.");
    }
}

Nested Classes (Nested Classes):
Applying static to a nested class makes it a static nested class. Such a class does not have a hidden reference to an outer instance and can be created independently of an outer class instance. It can only access static members of the outer class.
```
// Example of a static nested class
public class OuterClass {
    static class StaticNestedClass {
        // Members of the static nested class
    }
}
```

Interfaces: From Java 8, static methods can be declared in interfaces.

// Example of a static method in an interface
interface MyInterface {
    static void staticMethod() {
        System.out.println("Static method in interface.");
    }
}

The static modifier cannot be applied to local variables (defined inside methods), constructors, or top-level external classes.

To which constructs in Java can the static modifier be applied?