Interface use cases in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an interface named Speaker.

Go

type Speaker interface {
	[1]
}

Drag options to blanks, or click blank then click option'

ASpeak(string)

Bspeak()

CSpeak

DSpeak()

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting parentheses in the method declaration.

Using lowercase method names when uppercase is expected.

The interface method must include parentheses even if it has no parameters, so Speak() is correct.

2fill in blank

medium

Complete the code to make type Dog implement the Speaker interface.

Go

type Dog struct {}

func (d Dog) [1] {
	fmt.Println("Woof!")
}

Drag options to blanks, or click blank then click option'

ASpeak

BSpeak()

Cspeak()

DBark()

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different method name than the interface requires.

Omitting parentheses in the method declaration.

To implement the Speaker interface, Dog must have a method Speak() matching the interface method exactly.

3fill in blank

hard

Fix the error in the code to assign a Dog to a Speaker interface variable.

Go

var s Speaker
var d Dog
s = [1]

Drag options to blanks, or click blank then click option'

A*d

B&d

Cd

DSpeaker(d)

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning a pointer when the method has a value receiver.

Trying to cast the type unnecessarily.

Since Dog implements Speaker by value receiver, assigning d directly works. Using &d would also work if the method had pointer receiver.

4fill in blank

hard

Fill both blanks to create a map of string keys to Speaker interface values, and add a Dog instance.

Go

var animals = map[string][1]{}

animals["dog"] = [2]

Drag options to blanks, or click blank then click option'

ASpeaker

BDog{}

CAnimal{}

DSpeaker{}

Attempts:

3 left

💡 Hint

Common Mistakes

Using a concrete type instead of the interface as map value.

Trying to assign an interface literal which is invalid.

The map value type must be the interface Speaker. To add a Dog, use Dog{} which implements Speaker.

5fill in blank

hard

Fill all three blanks to define an interface, implement it with a Cat struct, and call the method.

Go

type [1] interface {
	[2]()
}

type Cat struct {}

func (c Cat) [2]() {
	fmt.Println("Meow!")
}

func main() {
	var s [1] = Cat{}
	s.[2]()
}

Drag options to blanks, or click blank then click option'

ASpeaker

BSpeak

CSpeak()

DAnimal

Attempts:

3 left

💡 Hint

Common Mistakes

Including parentheses in blanks where only method names are expected.

Using different names for interface and method.

The interface is named Speaker. The method is Speak(), but blanks expect only the method name Speak without parentheses. The method receiver and call use Speak.

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