Interface use cases in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an interface in Go?

An interface in Go is a type that defines a set of method signatures. Any type that implements those methods satisfies the interface, allowing for flexible and reusable code.

intermediate

How do interfaces help with polymorphism in Go?

Interfaces allow different types to be treated the same way if they implement the same methods. This means you can write functions that work with any type that satisfies an interface, enabling polymorphism.

beginner

Give a real-life example of using interfaces in Go.

Imagine a payment system where different payment methods like CreditCard and PayPal implement a Pay interface with a Pay() method. The system can process any payment method through the Pay interface without knowing the details.

intermediate

Why are interfaces useful for testing in Go?

Interfaces allow you to create mock implementations of dependencies. This means you can test your code by substituting real components with mocks that implement the same interface, making tests simpler and more reliable.

beginner

What happens if a type does not implement all methods of an interface in Go?

The type does not satisfy the interface and cannot be used where that interface is expected. Go checks this at compile time, preventing runtime errors.

What must a type do to satisfy an interface in Go?

A Use the interface as a field

B Embed the interface explicitly

C Implement all methods declared in the interface

D Declare the interface in its type definition

In Go, a type satisfies an interface by implementing all the methods declared in that interface.

Which of these is a common use case for interfaces in Go?

A Declaring variables

B Enabling polymorphism

C Defining constants

D Managing memory

Interfaces enable polymorphism by allowing different types to be used interchangeably if they implement the same methods.

How do interfaces help with testing in Go?

A By allowing mock implementations of dependencies

B By speeding up compilation

C By enforcing strict type casting

D By automatically generating test cases

Interfaces let you create mock versions of components for testing, improving test isolation and reliability.

If a type implements only some methods of an interface, what happens?

A It causes a runtime error

B It partially satisfies the interface

C It satisfies the interface automatically

D It does not satisfy the interface

A type must implement all methods of an interface to satisfy it; partial implementation is not enough.

Which statement about Go interfaces is true?

A Interfaces are satisfied implicitly

B Interfaces must be explicitly declared in types

C Interfaces can only have one method

D Interfaces store data

Go interfaces are satisfied implicitly by implementing the required methods, no explicit declaration is needed.

Explain how interfaces enable polymorphism in Go with an example.

Think about how different types can be used interchangeably if they have the same methods.

Describe how interfaces improve testing in Go programs.

Consider how you can replace real components with fake ones during tests.

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