What are Interfaces in Go?

In Go, an interface is a type that specifies a set of method signatures. It's a contract that defines what methods a type must have to be considered to implement that interface. Go uses structural typing, meaning a type implements an interface simply by possessing all the methods defined in the interface, regardless of whether it explicitly declares its intention to implement the interface. This contrasts with languages like Java, where a class must explicitly declare that it implements an interface.

Think of an interface as a promise. If a type fulfills that promise (i.e., provides implementations for all methods specified in the interface), then it's considered to be of that interface type.

How Interfaces Enable Polymorphism and Code Reusability

Interfaces are central to achieving polymorphism and promoting code reusability in Go. Here's how:

Polymorphism

Polymorphism means "many forms." Using interfaces, you can write code that operates on values of different types as long as those types implement a common interface. This allows you to treat different types in a uniform way, simplifying your code and making it more flexible.

For example, imagine you have an interface called Shape with a method called Area(). You could have structs like Circle, Rectangle, and Triangle, each implementing the Shape interface by providing its own Area() method. You could then write a function that takes a Shape as input and calculates its area, without needing to know the specific type of shape. This function would work for any type that implements the Shape interface.

Code Reusability

Interfaces promote code reusability by allowing you to write generic functions that work with any type that implements a specific interface. This eliminates the need to write separate functions for each type, reducing code duplication and making your code more maintainable.

Following the Shape example, you can create utility functions that operate on any Shape. This allows you to reuse your code across different shape types, reducing the need to write specialized functions for each individual type. This increases code maintainability because changes to the shared functions are reflected in all shapes.

Defining and Implementing Interfaces

Defining an Interface

To define an interface, you use the type keyword followed by the interface name and the interface keyword. Inside the curly braces, you define the method signatures (name, parameters, and return types) that the interface requires.

 type Shape interface {
    Area() float64
    Perimeter() float64
} 

This defines an interface called Shape with two methods: Area() which returns a float64, and Perimeter(), which also returns a float64.

Implementing an Interface with Structs

To implement an interface, a struct (or any type, actually) simply needs to have methods with the same names, parameters, and return types as the methods defined in the interface. Go doesn't require you to explicitly declare that a struct implements an interface; it's implicit based on the method set. This is known as "duck typing": "If it walks like a duck and quacks like a duck, then it must be a duck."

 type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2* (r.Width + r.Height)
} 

In this example, both the Circle and Rectangle structs implement the Shape interface because they both have Area() and Perimeter() methods that match the interface's signatures.

Using the Interface

Now you can use the Shape interface to write code that works with both Circle and Rectangle types:

 import "fmt"
import "math"

func printShapeInfo(s Shape) {
    fmt.Printf("Area: %f\n", s.Area())
    fmt.Printf("Perimeter: %f\n", s.Perimeter())
}

func main() {
    c := Circle{Radius: 5}
    r := Rectangle{Width: 4, Height: 6}

    printShapeInfo(c)
    printShapeInfo(r)
} 

The printShapeInfo function accepts any value that implements the Shape interface. This demonstrates polymorphism, as the same function can operate on different types. This is crucial for code reusability and flexibility.