Interface (object-oriented programming)

Abstraction of a class

In object-oriented programming, an interface or protocol type[a] is a data type that acts as an abstraction of a class. It describes a set of method signatures, the implementations of which may be provided by multiple classes that are otherwise not necessarily related to each other.[1] A class which provides the methods listed in an interface is said to implement the interface,[1] or to adopt the protocol.[2]

If objects are fully encapsulated then the interface is the only way in which they may be accessed by other objects. For example, in Java, the `Comparable` interface specifies a method `compareTo()` which implementing classes must implement. This means that a sorting method, for example, can sort a collection of any objects of types which implement the Comparable interface, without having to know anything about the inner nature of the class (except that two of these objects can be compared by means of `compareTo()`).

## Examples

[edit]

Some programming languages provide explicit language support for interfaces: Ada, C#, D, Dart, Delphi, Go, Java, Logtalk, Object Pascal, Objective-C, OCaml, PHP, Racket, Seed7, Swift, Python 3.8. In languages supporting multiple inheritance, such as C++, interfaces are implemented as abstract classes.

An example of syntax for interfaces may look like the following:

class Animal { ... }
class Theropod extends Animal { ... }

interface Flyable {
void fly();

interface Vocal {
void vocalize();

public class Bird extends Theropod implements Flyable, Vocal {
// ...
public void fly() { ... }
public void vocalize() { ... }

In languages without explicit support, interfaces are often still present as conventions; this is known as duck typing. For example, in Python, any class can implement an `__iter__` method and be used as a collection.[3]

Type classes in languages like Haskell, or module signatures in ML and OCaml, are used for many of the things that interfaces are used for.[clarification needed]

In Rust, interfaces are called traits.[4] In Rust, `struct`s do not have methods, but instead implement `trait`s which declare methods that the `struct` implements.

trait Pet {
fn speak(&self);

struct Dog<'a> {
name: &'a str

impl<'a> Dog<'a> {
fn new(name: &'a str) -> Self {
Dog { name }

impl Pet<'a> for Dog<'a> {
fn speak(&self) {
println!("{} says 'Woof!'", self.name);

## See also

[edit]

* Concept (generic programming)
* Delegation (programming)
* Protocols in Objective-C
* Class (computer science)
* Encapsulation (computer science)
* Public interface
* Interface (Java)
* Application programming interface
* Interface (computing)
* List of basic computer science topics

## Notes

[edit]

1. ^ Usage of these terms varies by programming language. Java and languages derived from it tend to use "interface", while "protocol" is generally more popular elsewhere.

## References

[edit]

1. ^ a b "Interfaces - define behavior for multiple types". learn.microsoft.com. Retrieved 16 November 2022.
2. ^ Miller, BJ (2015). Sams Teach Yourself Swift in 24 hours. Indianapolis, Indiana. p. 263\. ISBN 978-0-672-33724-6. "Any type can adopt a protocol to help give it extra functionality to accomplish a particular set of tasks."`{{cite book}}`: CS1 maint: location missing publisher (link)
3. ^ "Glossary — Python 3.11.0 documentation". docs.python.org. Retrieved 16 November 2022.
4. ^ "Traits - The Rust Reference". January 2024.

* v
* t
* e

Data types

Uninterpreted|

* Bit
* Byte
* Trit
* Tryte
* Word
* Bit array

Numeric|

* Arbitrary-precision or bignum
* Complex
* Decimal
* Fixed point
* Block floating point
* Floating point
* Reduced precision
* Minifloat
* Half precision
* bfloat16
* Single precision
* Double precision
* Quadruple precision
* Octuple precision
* Extended precision
* Long double
* Integer
* signedness
* Interval
* Rational

Pointer|

* Address
* physical
* virtual
* Reference

Text|

* Character
* String
* null-terminated

Composite|

* Algebraic data type
* generalized
* Array
* Associative array
* Class
* Dependent
* Equality
* Inductive
* Intersection
* List
* Object
* metaobject
* Option type
* Product
* Record or Struct
* Refinement
* Set
* Union
* tagged

Other|

* Boolean
* Bottom type
* Collection
* Enumerated type
* Exception
* Function type
* Opaque data type
* Recursive data type
* Semaphore
* Stream
* Strongly typed identifier
* Top type
* Type class
* Empty type
* Unit type
* Void

Related
topics|

* Abstract data type
* Boxing
* Data structure
* Generic
* Kind
* metaclass
* Parametric polymorphism
* Primitive data type
* Interface
* Subtyping
* Type constructor
* Type conversion
* Type system
* Type theory
* Variable

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template