TLDR: Static binding, also known as early binding, is the process where method resolution, function resolution, or variable resolution is determined at compile time. It is primarily used for methods or fields in a program that are final, private, or static, as their definitions are known in advance. Static binding enhance OOP performance and type safety by eliminating the need for runtime decisions.

https://en.wikipedia.org/wiki/Early_binding

In Java and CPP, static binding occurs for methods that are declared static, declared final, or declared private because these cannot be overridden. For example, if a method `display()` is defined as `static`, the call to `ClassName.display()` is resolved at compile time. Similarly, references to instance variables are resolved using static binding, ensuring that the program invokes the correct method or accesses the appropriate variable during execution.

https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html

While static binding is efficient, as decisions are made before runtime, it lacks the flexibility of dynamic binding needed for polymorphism. For instance, overridden methods rely on runtime resolution to determine the appropriate implementation based on the actual object type. Static binding is ideal for use cases where the behavior is fixed and unchanging, making it a critical aspect of object-oriented programming for performance-critical operations.

https://docs.oracle.com/javase/specs/jls/se20/html/jls-8.html