Why interfaces are used in Go - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of Interfaces in Go

Why do programmers use interfaces in Go?

A To define a set of method signatures that types can implement, enabling polymorphism and flexible code design.

B To store data permanently on disk for later retrieval.

C To create variables that can only hold integer values.

D To directly manipulate memory addresses for performance.

💡 Hint

Think about how interfaces help different types work together by sharing common behaviors.

Interfaces in Go specify method sets that types can implement. This allows different types to be treated the same way if they implement the same interface, enabling flexible and reusable code.

❓ Predict Output

intermediate

Output of Interface Usage Example

What is the output of this Go program using interfaces?

Go

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

A

Woof!
Meow!

B

Woof!
Woof!

C

Meow!
Woof!

D Compilation error due to missing method implementation

💡 Hint

Each struct implements Speak differently; the function prints each result.

The Dog and Cat types both implement the Speaker interface by defining Speak(). The saySomething function calls Speak() on each, printing their unique sounds.

🔧 Debug

advanced

Identify the Interface Implementation Error

What error will this Go code produce and why?

Go

package main
import "fmt"
type Reader interface {
    Read() string
}
type File struct {}
func (f File) Read() string {
    return "file content"
}
func main() {
    var r Reader
    r = File{}
    fmt.Println(r.Read())
    r = nil
    fmt.Println(r.Read())
}

A

Output:
file content
panic: interface conversion error

B Compilation error: cannot assign nil to interface variable

C panic: runtime error: invalid memory address or nil pointer dereference

D

Output:
file content
<empty string>

💡 Hint

Consider what happens when calling a method on a nil interface value.

Assigning nil to the interface variable r means it holds no concrete value. Calling a method on a nil interface causes a runtime panic due to nil pointer dereference.

📝 Syntax

advanced

Which Option Correctly Defines an Interface?

Which of the following Go code snippets correctly defines an interface named 'Mover' with a method 'Move() string'?

A type Mover interface Move() string

B

interface Mover {
    Move() string
}

C

type Mover struct {
    Move() string
}

D

type Mover interface {
    Move() string
}

💡 Hint

Remember the Go syntax for defining interfaces uses 'type' and 'interface' keywords.

Option D uses the correct Go syntax for defining an interface. Options A, B, and D have syntax errors or misuse struct instead of interface.

🚀 Application

expert

Using Interfaces for Flexible Function Arguments

Given these types and interface, which option correctly calls the function 'process' with different types implementing the 'Processor' interface?

Go

package main
import "fmt"
type Processor interface {
    Process() string
}
type Image struct {}
func (i Image) Process() string {
    return "Processing image"
}
type Text struct {}
func (t Text) Process() string {
    return "Processing text"
}
func process(p Processor) {
    fmt.Println(p.Process())
}
func main() {
    img := Image{}
    txt := Text{}
    // Which call is correct here?
}

A

process(&img)
process(&txt)

B

process(img)
process(txt)

C

process(img)
process(&txt)

D

process(&img)
process(txt)

💡 Hint

Check if the Process method has pointer or value receiver and match the argument accordingly.

Both Image and Text implement Process with value receivers, so passing values (not pointers) works. Passing pointers would also work but is not required here.