Interfaces and Composition in GoLang: The Power of Abstraction and Flexibility

Aditya Joshi

·

Follow

Published in

Level Up Coding

·

5 min read

·

Jun 25

51

Listen

Share

GoLang is a powerful programming language known for its simplicity, performance, and strong support for concurrency. One of the key features that makes GoLang stand out is its emphasis on interfaces and composition, which enable developers to write clean, modular, and highly reusable code. In this article, we will explore the concepts of interfaces and composition in GoLang and understand how they contribute to the language’s elegance and flexibility.

Interfaces in Golang?

Interfaces in GoLang serve as contracts that define a set of methods. Unlike other object-oriented languages, GoLang interfaces are implicit. In other words, a type in GoLang automatically satisfies an interface if it implements all the methods defined by that interface. This approach allows for greater flexibility and extensibility when working with different types.

To define an interface in GoLang, we use the interface keyword followed by a set of method signatures. Here's an example of a simple interface called Shape:

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

In the above example, Shape is an interface that defines two methods: Area() and Perimeter(), both of which return a float64 value. Any type that implements these two methods will automatically satisfy the Shape interface.

Let’s say we have two types: Rectangle and Circle. To make these types satisfy the Shape interface, we need to implement the required methods. Here's an example of how we can achieve that:

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)
}

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
}

In the code snippet above, we defined two types, Rectangle and Circle, and implemented the Area() and Perimeter() methods for each type. Now, both Rectangle and Circle satisfy the Shape interface.