Why interfaces are used in Go - Visual Breakdown

Concept Flow - Why interfaces are used

Define Interface

↓

Create Types that Implement Interface

↓

Use Interface Type to Hold Any Implementing Type

↓

Call Methods via Interface

↓

Achieve Flexibility and Abstraction

Interfaces define behavior without specifying exact types, allowing different types to be used interchangeably through shared methods.

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 = Dog{}
    fmt.Println(s.Speak())
}

Defines an interface Speaker and a type Dog that implements Speak method.

Execution Table

Step	Action	Evaluation	Result
1	Define interface Speaker with Speak() method	Speaker interface created	Interface expects Speak() string
2	Define Dog struct	Dog type created	Dog has no methods yet
3	Implement Speak() method for Dog	Dog now implements Speaker	Dog can be used as Speaker
4	Create variable var s Speaker = Dog{}	Dog instance assigned to Speaker variable	s holds Dog as Speaker
5	Call s.Speak()	Calls Dog's Speak method	Returns "Woof!"
6	End of program	No more actions	Program ends

💡 Program ends after calling Speak method on interface variable

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
s	nil	Dog instance assigned	s.Speak() returns "Woof!"	Dog instance remains

Key Moments - 3 Insights

Why can we assign a Dog to a variable of type Speaker without explicit conversion?

Because Dog implements the Speak() method required by Speaker, Go allows implicit assignment as shown in step 4 of the execution_table.

What happens when we call s.Speak() if s holds a Dog?

The Dog's Speak() method is called, returning "Woof!" as shown in step 5 of the execution_table.

Why use interfaces instead of concrete types directly?

Interfaces allow writing flexible code that works with any type implementing the interface, enabling abstraction and easier code reuse.

Visual Quiz - 3 Questions

Look at the execution_table, what type does variable s hold after step 4?

A Speaker interface only

B nil

C Dog instance

D string

💡 Hint

Check the 'Action' and 'Result' columns in step 4 of execution_table

At which step does Dog become recognized as implementing Speaker?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Evaluation' column in step 3 of execution_table

If Dog did not implement Speak(), what would happen at step 4?

A Compilation error

B s would hold nil

C Dog assigned anyway

D Runtime panic

💡 Hint

Interfaces require implementing methods; see step 4 assignment in execution_table

Concept Snapshot

Interfaces define method sets without implementation.
Types implement interfaces by defining those methods.
Variables of interface type can hold any implementing type.
This enables flexible, abstract code that works with many types.
Go checks implementation implicitly at compile time.

Full Transcript

This visual execution shows why interfaces are used in Go. First, we define an interface Speaker with a Speak() method. Then, we create a Dog type and implement Speak() for it. Because Dog has the required method, it automatically implements Speaker. We assign a Dog instance to a variable of type Speaker. When we call Speak() on that variable, the Dog's method runs, returning "Woof!". This shows how interfaces allow different types to be used interchangeably, enabling flexible and abstract programming.