interfacetype

An interface type is a type that specifies a set of method signatures (and, in some languages, properties and events) without providing implementations. It defines a contract that other types can implement, enabling polymorphism by allowing code to operate on values solely through the interface.

A type satisfies an interface by providing the required members. In statically typed languages, this relationship may be implicit (structural typing) or explicit (nominal typing). In dynamic or duck-typed languages, an object is treated as implementing an interface if it has the required methods, regardless of declared intent.

Go uses interface types with implicit satisfaction: a type implements an interface if it has the necessary methods, without an explicit declaration. Java and C# use nominal interfaces with explicit implements declarations. TypeScript describes interfaces as a compile-time shape that may be structural, meaning an object’s shape determines compatibility rather than a declared relationship.

Interface types enable polymorphic APIs and decoupling between code and concrete implementations. They are commonly used for abstracting over behavior, enabling testing with mocks, and passing behavior as values through higher-order functions or callbacks. They also support dynamic dispatch in many languages, allowing the same code to operate on diverse concrete types.

A common distinction is between interfaces and abstract classes. Interfaces typically define a contract without shared state, while abstract classes can provide common implementation and state. Some languages allow default method implementations within interfaces, while others require separate abstract classes for shared behavior.

In summary, interface types formalize a contract of behavior that multiple concrete types can share, enabling flexible, decoupled designs and polymorphism across various programming paradigms.