Mastering Golang: Interfaces Part 3

Go Interfaces with pointers

Leveraging Interfaces with Pointers and Receivers!

Welcome to the world of Golang! Interfaces play a significant role in achieving polymorphism and abstraction in your code. Understanding how interfaces work with pointers and receivers is crucial for writing effective and flexible Go programs.

Let’s break down the concepts:


An interface in Go is a type that specifies a set of method signatures. Any type that implements all the methods declared in an interface is said to satisfy that interface. Interfaces enable you to write functions and methods that can work with different types as long as they adhere to the specified method signatures.

Pointers and Receivers

  • Pointers: In Go, you can define methods on types, both on the value type and its pointer type. For example, if you have a type MyType, you can define methods with receivers of both MyType and *MyType. The difference is in how they are called and how they operate on the value.
  • Receivers: A method with a receiver of type MyType operates on the value of that type and can only modify its internal state if the receiver is a pointer. A method with a receiver of type *MyType operates on a pointer to the value and can modify the internal state of the value it points to.

Golang Code Example

Here’s an example illustrating these concepts:

package main

import (

// MyType is a simple user-defined type.
type MyType struct {
	data int

// Method with a receiver of MyType (value receiver).
func (m MyType) SetValue(value int) { = value // This modifies a copy of the MyType instance.

// Method with a receiver of *MyType (pointer receiver).
func (m *MyType) SetValueWithPointer(value int) { = value // This modifies the original MyType instance.

// MyInterface is an interface with a method that takes no arguments and returns an int.
type MyInterface interface {
	GetValue() int

// Implementing MyInterface for MyType with a pointer receiver.
func (m *MyType) GetValue() int {

func main() {
	// Create an instance of MyType.
	instance := MyType{data: 42}

	// Call methods with both value and pointer receivers.
	fmt.Println("Value Receiver - After SetValue:", // This will print 42 because SetValue operates on a copy.
	fmt.Println("Pointer Receiver - After SetValueWithPointer:", // This will print 200 because SetValueWithPointer operates on the original instance.

	// Interface usage with a pointer receiver.
	var myInterface MyInterface
	myInterface = &instance
	fmt.Println("Interface method call:", myInterface.GetValue()) // This will print 200 because GetValue operates on the original instance.
Breaking Down the Code
  • SetValue uses a value receiver, so it operates on a copy of the MyType instance.
  • SetValueWithPointer uses a pointer receiver, so it operates on the original MyType instance.
  • MyInterface is implemented by MyType with a pointer receiver, allowing you to assign an instance of MyType to an interface variable and call its methods via the interface.


Utilizing pointer receivers in interface implementations provides enhanced flexibility and performance in Go code. Understanding these concepts is crucial for effective use of interfaces and receiver types in Go. It allows you to design flexible and maintainable code that can work with various types while preserving the intended behavior.

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