Interface use cases in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of interface method call

What is the output of this Go program that uses an interface to call a method?

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

A Woof!

B Compilation error

C speak

D Woof

💡 Hint

Check the Speak method implementation and what it returns.

The Dog type implements the Speaker interface by defining Speak() string. The method returns "Woof!" exactly, so printing s.Speak() outputs "Woof!".

🧠 Conceptual

intermediate

Why use interfaces in Go?

Which of the following is the main reason to use interfaces in Go?

A To enable polymorphism and write flexible code that works with different types

B To improve program speed by avoiding function calls

C To declare variables with fixed memory size

D To enforce inheritance like in other languages

💡 Hint

Think about how interfaces allow different types to be used interchangeably.

Interfaces in Go allow different types to implement the same set of methods, enabling polymorphism and flexible code that can work with any type implementing the interface.

🔧 Debug

advanced

Identify the runtime error with interface nil check

What error will this Go program produce when run?

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
    var f *File = nil
    r = f
    if r == nil {
        fmt.Println("Reader is nil")
    } else {
        fmt.Println(r.Read())
    }
}

A Compilation error

B file content

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

D Reader is nil

💡 Hint

Check how interface values with nil underlying pointers behave in comparisons.

The interface r holds a *File pointer which is nil, but the interface itself is not nil. So r == nil is false, and calling r.Read() works because the method has a receiver pointer and does not dereference the pointer inside the method. It returns "file content".

📝 Syntax

advanced

Which code snippet correctly implements an interface?

Given interface Writer with method Write(string) error, which option correctly implements it?

Go

type Writer interface {
    Write(s string) error
}

A

type File struct {}
func Write(f File, s string) error {
    return nil
}

B

type File struct {}
func (f *File) Write() error {
    return nil
}

C

type File struct {}
func (f File) Write(s int) error {
    return nil
}

D

type File struct {}
func (f File) Write(s string) error {
    return nil
}

💡 Hint

Check method signature matches exactly the interface method.

Option D defines Write with receiver File and parameter string, returning error, matching the interface exactly. A misses the string parameter. C has wrong parameter type. D is a function, not a method.

🚀 Application

expert

How many types implement this interface?

Given the interface and types below, how many distinct types implement the interface Printable?

Go

package main
import "fmt"
type Printable interface {
    Print()
}
type A struct {}
func (a A) Print() { fmt.Println("A") }
type B struct {}
func (b *B) Print() { fmt.Println("B") }
type C struct {}
func (c C) Print() { fmt.Println("C") }
func main() {}

A 2

B 1

C 3

D 0

💡 Hint

Remember that in Go, types with pointer receiver methods also implement the interface via automatic address taking.

A has Print() with value receiver, so A implements Printable. B has Print() with pointer receiver, so B implements Printable (Go automatically uses &b.Print()). C has Print() with value receiver, so C implements Printable. So three types implement Printable: A, B, and C.

Practice

1. What is the main purpose of an interface in Go?

easy

A. To define a set of method signatures that a type must implement

B. To store data values of different types

C. To create a new data type with fields

D. To perform arithmetic operations

Solution

1. Step 1: Understand what an interface represents

   An interface in Go lists method signatures without implementations.

2. Step 2: Identify the role of interfaces

   Any type that implements those methods satisfies the interface, enabling flexible code.

3. Final Answer:

   To define a set of method signatures that a type must implement -> Option A

4. Quick Check:

   Interface = method signatures [OK]

Hint: Interfaces list methods, not data or operations [OK]

Common Mistakes:

• Confusing interfaces with structs
• Thinking interfaces hold data
• Assuming interfaces perform calculations

2. Which of the following is the correct way to declare an interface named Speaker with a method Speak() in Go?

easy

A. func Speaker() interface { Speak() }

B. interface Speaker { func Speak() }

C. type Speaker struct { Speak() }

D. type Speaker interface { Speak() }

Solution

1. Step 1: Recall Go interface syntax

   Interfaces are declared with type Name interface { methods }.

2. Step 2: Match the correct syntax

   type Speaker interface { Speak() } correctly declares Speaker as an interface with method Speak().

3. Final Answer:

   type Speaker interface { Speak() } -> Option D

4. Quick Check:

   Interface declaration = type Speaker interface { Speak() } [OK]

Hint: Use 'type Name interface { ... }' to declare interfaces [OK]

Common Mistakes:

• Using 'interface' keyword alone without 'type'
• Declaring interfaces as structs
• Adding 'func' keyword inside interface methods

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

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

medium

A. Woof!

B. Compilation error

C. Runtime panic

D. No output

Solution

1. Step 1: Check if Dog implements Speaker

   Dog has method Speak(), so it satisfies Speaker interface.

2. Step 2: Trace function call

   In main, saySomething(d) calls d.Speak(), printing "Woof!".

3. Final Answer:

   Woof! -> Option A

4. Quick Check:

   Interface method call prints "Woof!" [OK]

Hint: Check if type has all interface methods to predict output [OK]

Common Mistakes:

• Assuming interface needs explicit implementation declaration
• Expecting compilation error due to interface
• Missing method receiver syntax

4. Identify the error in this Go code snippet using interfaces:

package main
import "fmt"
type Reader interface {
  Read()
}
type File struct {}
func (f *File) Read() {
  fmt.Println("Reading file")
}
func main() {
  var r Reader
  f := File{}
  r = f
  r.Read()
}

medium

A. Interface Reader cannot have methods

B. Method Read() must return a value

C. Cannot assign value of type File to Reader interface

D. No error, code runs fine

Solution

1. Step 1: Check method receiver type

   Read() is defined on pointer receiver *File, not on File value.

2. Step 2: Understand interface assignment rules

   Assigning f (value) to interface r fails because File does not implement Read(), only *File does.

3. Final Answer:

   Cannot assign value of type File to Reader interface -> Option C

4. Quick Check:

   Pointer receiver methods require pointer type assignment [OK]

Hint: Pointer receiver methods need pointer type to satisfy interfaces [OK]

Common Mistakes:

• Ignoring pointer vs value receiver difference
• Expecting interface to accept any type
• Thinking methods must return values

5. Given these types and interfaces:

type Walker interface {
  Walk()
}
type Runner interface {
  Run()
}
type Athlete interface {
  Walker
  Runner
}
type Person struct {}
func (p Person) Walk() {
  fmt.Println("Walking")
}
func (p Person) Run() {
  fmt.Println("Running")
}

Which of the following statements is true?

hard

A. Person must explicitly declare it implements Athlete

B. Person implements Athlete because it has both Walk and Run methods

C. Athlete interface cannot embed other interfaces

D. Person only implements Walker, not Athlete

Solution

1. Step 1: Understand interface embedding

   Athlete embeds Walker and Runner, so it requires both Walk() and Run() methods.

2. Step 2: Check Person methods

   Person has both Walk() and Run() methods, so it satisfies Athlete interface automatically.

3. Final Answer:

   Person implements Athlete because it has both Walk and Run methods -> Option B

4. Quick Check:

   Interface embedding means combined methods [OK]

Hint: Embedded interfaces combine methods; implement all to satisfy [OK]

Common Mistakes:

• Thinking explicit declaration is needed
• Believing interface embedding is invalid
• Assuming partial method implementation suffices