Interface use cases in Go - Step-by-Step Execution

Concept Flow - Interface use cases

Define Interface

↓

Create Structs implementing Interface

↓

Assign Structs to Interface Variable

↓

Call Interface Methods

↓

Use Polymorphism: Different Structs, Same Interface

↓

Pass Interface to Functions

↓

Interface Enables Flexible Code

This flow shows how interfaces are defined, implemented by structs, assigned, and used to enable flexible and polymorphic code.

Execution Sample

Go

package main
import "fmt"
type Speaker interface {
    Speak() string
}
type Dog struct {}
func (d Dog) Speak() string {
    return "Woof!"
}
func main() {
    var s Speaker
    d := Dog{}
    s = d
    fmt.Println(s.Speak())
}

Defines an interface Speaker and a struct Dog implementing Speak method.

Execution Table

Step	Action	Evaluation	Result
1	Define interface Speaker with Speak() string	Interface created	Speaker interface ready
2	Define struct Dog	Struct created	Dog struct ready
3	Implement Speak() method for Dog	Method attached	Dog implements Speaker
4	Create Dog instance d	d := Dog{}	d is Dog{}
5	Assign d to variable s of type Speaker	var s Speaker = d	s holds Dog as Speaker
6	Call s.Speak()	s.Speak()	"Woof!" returned
7	Pass s to function that accepts Speaker	func greet(sp Speaker) { fmt.Println(sp.Speak()) }	Function prints "Woof!"
8	Create another struct Cat implementing Speaker	Cat struct with Speak() returns "Meow!"	Cat implements Speaker
9	Assign Cat instance to s and call Speak()	s = Cat{}	s.Speak() returns "Meow!"
10	Exit	No more steps	Program ends

💡 All interface use cases demonstrated, program ends

Variable Tracker

Variable	Start	After Step 4	After Step 5	After Step 9	Final
d	undefined	Dog{}	Dog{}	Dog{}	Dog{}
s	nil	nil	Dog as Speaker	Cat as Speaker	Cat as Speaker

Key Moments - 3 Insights

Why can variable s hold different struct types?

Because s is of interface type Speaker, it can hold any value whose type implements the Speaker interface, as shown in execution_table rows 5 and 9.

What happens when we call s.Speak()?

The method of the actual struct stored in s is called, demonstrating polymorphism (rows 6 and 9).

Why define functions accepting interface types?

Functions accepting interfaces can work with any struct implementing that interface, making code flexible and reusable (row 7).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of s after step 5?

A Cat struct stored as Speaker interface

B nil

C Dog struct stored as Speaker interface

D Undefined

💡 Hint

Check the 'Result' column in row 5 of execution_table

At which step does s hold a Cat struct?

A Step 6

B Step 9

C Step 7

D Step 4

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table row 9

If Dog did not implement Speak(), what would happen when assigning d to s at step 5?

A Compilation error

B s would hold nil

C s would hold d anyway

D Runtime panic

💡 Hint

Interfaces require implementing methods; see step 3 and 5 in execution_table

Concept Snapshot

Interface use cases in Go:
- Define interface with method signatures
- Structs implement interface by defining methods
- Interface variables can hold any implementing struct
- Enables polymorphism: same interface, different behaviors
- Pass interfaces to functions for flexible code

Full Transcript

This visual execution traces how interfaces work in Go. First, an interface Speaker is defined with a Speak method. Then, a struct Dog implements this method. A Dog instance is assigned to a variable s of type Speaker. Calling s.Speak() runs Dog's method, returning "Woof!". Later, another struct Cat also implements Speaker. Assigning Cat to s and calling Speak returns "Meow!". This shows how interfaces enable polymorphism and flexible code by allowing different structs to be used interchangeably through a common interface.