## How are Interfaces Implemented in Go: Static Type or Dynamic Dispatch?

How are Interfaces Implemented in Go?

When examining interfaces in Go, different perspectives can lead to seemingly opposing understandings.

Scheme Representation

In the "Laws of Reflection" article, an interface value contains a (value, type) pair. For instance, assigning io.Reader to the variable r yields r = (tty, *os.File). Here, tty is the value, while *os.File represents the type of the underlying value. Despite the interface restriction to the Read method, the inner value retains its full type information.

Dynamic Dispatch

Conversely, another article states that the itable for a type implements specific interface methods. In the case of the Binary type implementing Stringer, its itable includes only the String method. This implies that the itable should reflect the static type of the interface value, as opposed to the underlying value's type.

Clarification

These two perspectives complement each other. "Laws of Reflection" examines interface values as seen through reflection, providing a simplified representation. The second article focuses on the dynamic dispatch mechanism that underlies interfaces, revealing the involvement of specific implementation methods.

The variable r indeed contains tty as its value and has the static type io.Reader, which is a wrapper interface providing access to the Read method. However, the underlying value tty retains its type as *os.File, including additional methods beyond Read.

In Go, interfaces are implemented through dynamic dispatch, where the runtime resolves which method implementation to call based on the concrete type of the wrapped value. The itable stores the implementation details for each interface method.

The above is the detailed content of ## How are Interfaces Implemented in Go: Static Type or Dynamic Dispatch?. For more information, please follow other related articles on the PHP Chinese website!