Method Resolution Process
TLDR: The method resolution process determines which method to invoke when a method call is made in a program, based on the class hierarchy, method signatures, and the object’s runtime type. This process is integral to object-oriented programming, enabling features like inheritance and polymorphism. The resolution can occur at compile-time or runtime, depending on the programming language and the method being invoked.
https://en.wikipedia.org/wiki/Polymorphism_(computer_science)
In languages like Java and CPP, the method resolution process for overloading happens at compile-time, where the compiler selects the appropriate method based on the parameters' type, number, and order. In contrast, overriding involves runtime resolution, where the method associated with the actual object's type is invoked. For example, a `move()` call on an `Animal` reference to a `Bird` object will execute the overridden `move()` method defined in `Bird`. This runtime resolution is achieved through mechanisms like the virtual method table (vtable).
https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html
Advanced features like dynamic dispatch rely heavily on the method resolution process to support extensibility and maintain modularity. This process enables design patterns like the strategy pattern and frameworks that depend on late binding of methods. While runtime resolution adds flexibility, it can also introduce slight runtime performance overhead. Understanding the method resolution process is essential for optimizing application behavior and ensuring correct method invocation in polymorphic designs.
https://docs.oracle.com/javase/specs/jls/se20/html/jls-15.html