Implementing interfaces in Go - Step-by-Step Execution

Concept Flow - Implementing interfaces

Define Interface

↓

Define Struct

↓

Implement Interface Methods on Struct

↓

Create Struct Instance

↓

Assign to Interface Variable

↓

Call Interface Methods

↓

Use Polymorphism

This flow shows how a struct implements an interface by defining required methods, then using the struct through the interface type.

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())
}

This code defines an interface Speaker and a struct Dog that implements it, then calls Speak through the interface.

Execution Table

Step	Action	Evaluation	Result
1	Define interface Speaker with method Speak()	Interface created	Speaker interface ready
2	Define struct Dog	Struct created	Dog struct ready
3	Implement Speak() method on Dog	Method attached	Dog now implements Speaker
4	Create Dog instance and assign to Speaker variable s	Dog{} assigned to s	s holds Dog as Speaker
5	Call s.Speak()	Calls Dog.Speak()	"Woof!" returned and printed
6	Program ends	No more code	Execution stops

💡 Program ends after printing "Woof!"

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
s	nil	Dog{} as Speaker	Dog{} as Speaker	Dog{} as Speaker

Key Moments - 3 Insights

Why can we assign Dog{} to a variable of type Speaker without explicit casting?

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

What happens if Dog does not implement Speak() method?

The assignment in step 4 would fail with a compile-time error, because Dog wouldn't satisfy the Speaker interface.

When calling s.Speak(), which method runs?

The Dog's Speak() method runs, as s holds a Dog instance implementing Speaker, shown in step 5.

Visual Quiz - 3 Questions

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

A Speaker interface without value

B nil

C Dog{} as Speaker

D Dog struct without interface

💡 Hint

Check variable_tracker row for s after step 4

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 execution_table step 3 where Speak() method is attached

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

A Compile-time error occurs

B Program runs but panics at runtime

C Assignment succeeds with nil value

D Dog is assigned but Speak() returns empty string

💡 Hint

Refer to key_moments about missing method causing assignment failure

Concept Snapshot

Go interfaces define method sets.
A struct implements an interface by having those methods.
No explicit declaration needed.
Assign struct instance to interface variable.
Call methods via interface for polymorphism.

Full Transcript

This example shows how in Go, interfaces are implemented by structs automatically when the struct has all the methods the interface requires. We define an interface Speaker with method Speak(). Then we define a struct Dog and add a Speak() method to it. Because Dog has Speak(), it implements Speaker. We create a Dog instance and assign it to a variable of type Speaker. When we call Speak() on that variable, Dog's Speak() runs and returns "Woof!". This demonstrates Go's interface implementation and polymorphism.

Practice

1. What does it mean for a type in Go to implement an interface?

easy

A. The type can only have one method.

B. The type inherits from the interface.

C. The type must be explicitly declared as implementing the interface.

D. The type has all the methods declared in the interface.

Solution

1. Step 1: Understand interface implementation in Go

   In Go, a type implements an interface by having all the methods the interface declares.

2. Step 2: Compare options with Go's rules

   Go does not use inheritance or explicit declarations for interfaces; it uses method sets.

3. Final Answer:

   The type has all the methods declared in the interface. -> Option D

4. Quick Check:

   Interface implementation = method set match [OK]

Hint: Check if all interface methods exist in the type [OK]

Common Mistakes:

• Thinking Go uses inheritance for interfaces
• Believing explicit declaration is needed
• Confusing interfaces with structs

2. Which of the following is the correct way to declare that a type implements an interface in Go?

easy

A. type MyType struct implements MyInterface {}

B. type MyType struct { MyInterface }

C. No explicit declaration needed; implement all interface methods

D. func (m MyType) implements() MyInterface {}

Solution

1. Step 1: Recall Go interface implementation syntax

   Go does not require explicit declarations; a type implements an interface by having all its methods.

2. Step 2: Analyze each option

   Options A, B, and D show invalid or non-Go syntax; only C correctly states Go's implicit implementation.

3. Final Answer:

   No explicit declaration needed; implement all interface methods -> Option C

4. Quick Check:

   Implicit implementation = No explicit declaration needed; implement all interface methods [OK]

Hint: Remember: Go uses implicit interface implementation [OK]

Common Mistakes:

• Trying to declare implementation explicitly
• Using inheritance syntax from other languages
• Adding interface as a struct field

3. What will be the output of the following Go code?

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

medium

A. Woof!

B. Compilation error: Dog does not implement Speaker

C. Runtime error

D. No output

Solution

1. Step 1: Check if Dog implements Speaker

   Dog has a method Speak() string, so it implements Speaker interface.

2. Step 2: Trace the function call saySomething(d)

   saySomething calls s.Speak(), which returns "Woof!" and prints it.

3. Final Answer:

   Woof! -> Option A

4. Quick Check:

   Interface method call prints "Woof!" [OK]

Hint: Check if method signatures match interface exactly [OK]

Common Mistakes:

• Assuming explicit declaration is needed
• Confusing method receiver types
• Expecting runtime errors without reason

4. Identify the error in this Go code that tries to implement an interface:

package main
import "fmt"
type Runner interface {
    Run()
}
type Person struct {}
func (p *Person) Run() {
    fmt.Println("Running")
}
func main() {
    var r Runner
    p := Person{}
    r = p
    r.Run()
}

medium

A. Missing Run() method in Person

B. Cannot assign Person value to Runner interface because Run() has pointer receiver

C. Interface Runner must have a return type

D. No error, code runs fine

Solution

1. Step 1: Check method receiver type

   Run() is defined with pointer receiver (*Person), so only *Person implements Runner.

2. Step 2: Analyze assignment r = p

   Variable p is a Person value, not *Person pointer, so it does not implement Runner.

3. Final Answer:

   Cannot assign Person value to Runner interface because Run() has pointer receiver -> Option B

4. Quick Check:

   Pointer receiver method requires pointer type [OK]

Hint: Match method receiver type with assigned variable type [OK]

Common Mistakes:

• Ignoring pointer vs value receiver difference
• Assuming interface methods must return values
• Thinking interface assignment always works

5. Given these interfaces and types, which assignment is valid in Go?

type Reader interface {
    Read() string
}
type Writer interface {
    Write(string)
}
type ReadWriter interface {
    Reader
    Writer
}
type File struct {}
func (f *File) Read() string {
    return "data"
}
func (f *File) Write(s string) {
    // write data
}
func main() {
    var rw ReadWriter
    var f File
    // Which assignment is valid?
}

hard

A. rw = &f

B. rw = f

C. rw = File{} (without methods)

D. rw = nil

Solution

1. Step 1: Check if File implements ReadWriter

   File has Read() and Write(string) with pointer receivers (*File), so only *File implements ReadWriter; File value does not.

2. Step 2: Analyze assignment options

   rw = &f is valid (&f is *File). rw = f fails (File doesn't implement). C invalid. rw = nil compiles but doesn't hold usable ReadWriter.

3. Final Answer:

   rw = &f -> Option A

4. Quick Check:

   Pointer receiver requires pointer type [OK]

Hint: Pointer receiver methods mean only pointer type implements interface [OK]

Common Mistakes:

• Thinking value type implements pointer receiver interface
• Assigning nil to interface without initialization
• Confusing interface embedding with inheritance