Mastering Golang: Interfaces Part 2

Golang Interfaces

Advanced Interface Implementation and Usage!

Welcome to the world of Golang! Interfaces are a fundamental concept that enable you to write flexible and reusable code by defining a set of method signatures without specifying the implementation details. In this more in-depth guide, I’ll explain what interfaces are, how to define them, how to use them, and some best practices.

What is an Interface in Go?

An interface in Go is a type that defines a set of method signatures. It doesn’t provide any implementation for these methods; instead, it describes what methods an implementing type must have. Any type that implements all the methods of an interface is said to satisfy that interface. This allows you to write code that can work with different types as long as they fulfill the expected method contracts.

Defining an Interface

To define an interface in Go, you use the type keyword followed by the interface keyword and a set of method signatures enclosed in curly braces. Here’s a simple example:

package main

import "fmt"

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

In this example, we’ve defined an Shape interface with two methods: Area() and Perimeter(). Any type that has these two methods with the appropriate signatures will implicitly implement the Shape interface.

Implementing an Interface

To implement an interface, a Go type needs to define methods with the same names and signatures as the methods specified in the interface. Let’s create a Rectangle type that implements the Shape interface:

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)

Now, the Rectangle type has Area() and Perimeter() methods with the correct signatures, so it implicitly implements the Shape interface.

Using Interfaces

One of the key benefits of interfaces is that you can write functions that work with any type that satisfies the interface. Here’s an example:

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

The PrintShapeInfo function accepts a parameter of type Shape, which means it can accept any type that implements the Shape interface.

Now, you can create instances of Rectangle and use the PrintShapeInfo function with them:

func main() {
    r := Rectangle{Width: 5, Height: 3}

Interface Composition

In Go, you can also create new interfaces by combining existing ones. This is known as interface composition. For example:

type Drawable interface {

type ShapeWithDrawing interface {

Here, ShapeWithDrawing is an interface that combines the Shape interface with a new Drawable interface.

Empty Interfaces

In Go, an empty interface (interface{}) can hold values of any type because it has no methods. This can be useful in situations where you need to work with arbitrary types, but use them in a generic way.

func PrintAnything(x interface{}) {

The PrintAnything function can accept values of any type because it takes an empty interface as its parameter.

Type Assertion

When you have an interface value and you want to access the underlying concrete type, you can use type assertion. Here’s an example:

var s Shape = Rectangle{Width: 4, Height: 3}

if rect, ok := s.(Rectangle); ok {
    fmt.Println("It's a Rectangle")
    fmt.Println("Width:", rect.Width)
    fmt.Println("Height:", rect.Height)
} else {
    fmt.Println("It's not a Rectangle")

In this example, we first assert that the s value is of type Rectangle, and if the assertion succeeds, we can access the fields and methods of the Rectangle type.


In Go, interfaces provide a powerful way to write flexible and reusable code. You define interfaces by specifying method signatures, and types implicitly implement those interfaces if they have methods with matching signatures. This allows you to write functions that can work with a wide range of types as long as they satisfy the interface’s contract. Interface composition and empty interfaces further enhance the flexibility of Go’s interface system.

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