Mastering Golang: Understanding Interfaces

Golang Interfaces

Leveraging the Power of Abstraction and Polymorphism!

Welcome to the world of Golang! Interfaces are a fundamental concept that enables you to define a set of method signatures without providing their implementations. Interfaces play a crucial role in achieving polymorphism and decoupling in Go, making your code more flexible and maintainable.

Here’s an overview of how interfaces work in Go:

Interface Declaration:

To declare an interface, you use the interface keyword followed by a set of method signatures.

Here’s a basic example:

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

In the above example, we define an interface called Shape with two method signatures: Area and Perimeter.

Implementing Interfaces:

To implement an interface, a Go type (struct, custom type, etc.) must provide definitions for all the methods declared in that interface. There’s no explicit keyword like implements or extends as in some other languages. Instead, Go uses implicit interface implementation.

For example, to implement the Shape interface, you might define a Circle struct and a Rectangle struct, each with their own implementations of Area and Perimeter methods.

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, Height float64

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

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

Now, both Circle and Rectangle satisfy the Shape interface because they implement the Area and Perimeter methods with the expected signatures.


Interfaces allow you to create functions that work with multiple types as long as they satisfy the interface. This enables polymorphism in Go, where you can write generic code that can operate on different types without knowing their specific implementations.

For example:

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

func main() {
    circle := Circle{Radius: 5.0}
    rectangle := Rectangle{Width: 4.0, Height: 3.0}

    PrintAreaAndPerimeter(circle)    // Works for Circle
    PrintAreaAndPerimeter(rectangle) // Works for Rectangle

In the main function, we call PrintAreaAndPerimeter with both a Circle and a Rectangle instance, demonstrating how the same function can work with different types as long as they satisfy the Shape interface.


Interfaces in Go provide a powerful tool for achieving abstraction and polymorphism, facilitating flexible and extensible code. Mastery of interfaces equips developers with the ability to create modular and adaptable solutions in Go programming.

That’s All Folks!

You can find all of our Golang guides here: A Comprehensive Guide to Golang

Luke Barber

Hello, fellow tech enthusiasts! I'm Luke, a passionate learner and explorer in the vast realms of technology. Welcome to my digital space where I share the insights and adventures gained from my journey into the fascinating worlds of Arduino, Python, Linux, Ethical Hacking, and beyond. Armed with qualifications including CompTIA A+, Sec+, Cisco CCNA, Unix/Linux and Bash Shell Scripting, JavaScript Application Programming, Python Programming and Ethical Hacking, I thrive in the ever-evolving landscape of coding, computers, and networks. As a tech enthusiast, I'm on a mission to simplify the complexities of technology through my blogs, offering a glimpse into the marvels of Arduino, Python, Linux, and Ethical Hacking techniques. Whether you're a fellow coder or a curious mind, I invite you to join me on this journey of continuous learning and discovery.

Leave a Reply

Your email address will not be published. Required fields are marked *

Verified by MonsterInsights