Why interfaces are used in Go - See It in Action

Why interfaces are used

📖 Scenario: Imagine you are building a program that handles different types of notifications, like emails and SMS messages. Each notification type sends messages differently, but your program should treat them the same way when sending.

🎯 Goal: Learn how to use interfaces in Go to write flexible code that can work with different notification types without changing the main sending logic.

📋 What You'll Learn

Create a struct for Email notification

Create a struct for SMS notification

Define an interface called Notifier with a method Send

Implement the Send method for both Email and SMS structs

Write a function that accepts the Notifier interface and calls Send

Demonstrate sending notifications using the interface

💡 Why This Matters

🌍 Real World

Interfaces are used in real programs to handle different data types with common behavior, like payment methods, shapes in graphics, or notification systems.

💼 Career

Understanding interfaces is key for Go developers to write clean, reusable, and scalable code in professional software projects.

1

DATA SETUP: Create Email and SMS structs

Create two structs called Email and SMS. The Email struct should have a field Address of type string. The SMS struct should have a field PhoneNumber of type string.

Go

# Your code here

Hint

Use type Email struct { Address string } and similarly for SMS.

2

CONFIGURATION: Define Notifier interface

Define an interface called Notifier with a method Send() that returns nothing.

Go

package main

type Email struct {
    Address string
}

type SMS struct {
    PhoneNumber string
}

// Your code here

Hint

Use type Notifier interface { Send() } to define the interface.

3

CORE LOGIC: Implement Send method for Email and SMS

Implement the Send() method for both Email and SMS structs. For Email, print "Sending email to " followed by the Address. For SMS, print "Sending SMS to " followed by the PhoneNumber.

Go

package main

type Email struct {
    Address string
}

type SMS struct {
    PhoneNumber string
}

type Notifier interface {
    Send()
}

// Your code here

Hint

Define methods with func (e Email) Send() and func (s SMS) Send() that print the messages.

4

OUTPUT: Use Notifier interface to send notifications

Create a function called Notify that takes a parameter n of type Notifier and calls n.Send(). Then create an Email with Address "[e-mail]" and an SMS with PhoneNumber "[phone]". Call Notify with both values. Print the output.

Go

package main

type Email struct {
    Address string
}

type SMS struct {
    PhoneNumber string
}

type Notifier interface {
    Send()
}

func (e Email) Send() {
    println("Sending email to " + e.Address)
}

func (s SMS) Send() {
    println("Sending SMS to " + s.PhoneNumber)
}

// Your code here

Hint

Define Notify function and call it with Email and SMS instances inside main().

Practice

1. Why are interfaces used in Go programming?

easy

A. To define a set of methods that different types can implement

B. To store data in a fixed format

C. To create variables with fixed values

D. To perform arithmetic operations

Solution

1. Step 1: Understand what interfaces represent

   Interfaces in Go define behavior by specifying method signatures without implementation.

2. Step 2: Recognize the purpose of interfaces

   They allow different types to implement the same set of methods, enabling flexible and interchangeable code.

3. Final Answer:

   To define a set of methods that different types can implement -> Option A

4. Quick Check:

   Interfaces define behavior = D [OK]

Hint: Interfaces describe behavior, not data storage [OK]

Common Mistakes:

• Thinking interfaces store data
• Confusing interfaces with variables
• Assuming interfaces perform calculations

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

easy

A. interface Reader { Read(p []byte) (n int, err error) }

B. type Reader interface { Read(p []byte) (n int, err error) }

C. func Reader interface { Read(p []byte) (n int, err error) }

D. var Reader interface = { Read(p []byte) (n int, err error) }

Solution

1. Step 1: Recall Go syntax for interface declaration

   Interfaces are declared using the 'type' keyword followed by the interface name and the 'interface' keyword with method signatures inside curly braces.

2. Step 2: Identify the correct syntax

   type Reader interface { Read(p []byte) (n int, err error) } correctly uses 'type Reader interface { ... }' syntax.

3. Final Answer:

   type Reader interface { Read(p []byte) (n int, err error) } -> Option B

4. Quick Check:

   Interface declaration starts with 'type' = A [OK]

Hint: Interfaces start with 'type Name interface' [OK]

Common Mistakes:

• Omitting 'type' keyword
• Using 'func' instead of 'type'
• Assigning interface to a variable incorrectly

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

C. Runtime panic

D. No output

Solution

1. Step 1: Understand interface implementation

   Dog type implements the Speaker interface by defining Speak() method returning "Woof!".

2. Step 2: Trace the function call

   saySomething is called with Dog instance, which calls Speak() and prints "Woof!".

3. Final Answer:

   Woof! -> Option A

4. Quick Check:

   Interface method called correctly = Woof! [OK]

Hint: Interface method calls print implemented method output [OK]

Common Mistakes:

• Expecting error due to interface
• Confusing method receiver types
• Thinking interface needs explicit declaration

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

package main
import "fmt"
type Walker interface {
    Walk()
}
type Cat struct {}
func (c Cat) Walk() {
    fmt.Println("Cat walks")
}
func main() {
    var w Walker
    w.Walk()
}

medium

A. Syntax error in interface declaration

B. Cat does not implement Walker interface

C. Variable w is nil and calling Walk() causes runtime panic

D. Walk method should return a value

Solution

1. Step 1: Analyze variable initialization

   Variable w of type Walker is declared but not assigned any value, so it is nil.

2. Step 2: Understand method call on nil interface

   Calling w.Walk() on nil interface causes a runtime panic because no concrete type implements the method at runtime.

3. Final Answer:

   Variable w is nil and calling Walk() causes runtime panic -> Option C

4. Quick Check:

   Calling method on nil interface = panic [OK]

Hint: Uninitialized interface variables cause runtime panic on method call [OK]

Common Mistakes:

• Assuming interface variable auto-initializes
• Thinking method must return value
• Confusing compile-time and runtime errors

5. You want to write a function that accepts any type that can Speak() and Walk(). How should you define the interface to achieve this in Go?

hard

A. Define two separate interfaces and pass both as parameters

B. Define an interface with only Speak method and ignore Walk

C. Use a struct with Speak and Walk methods instead of interface

D. Define a single interface embedding two interfaces: Speaker and Walker

Solution

1. Step 1: Understand interface embedding

   Go allows interfaces to embed other interfaces, combining their methods into one.

2. Step 2: Define combined interface

   By embedding Speaker and Walker interfaces, the new interface requires both Speak() and Walk() methods.

3. Final Answer:

   Define a single interface embedding two interfaces: Speaker and Walker -> Option D

4. Quick Check:

   Interface embedding combines behaviors = B [OK]

Hint: Embed interfaces to combine behaviors in one [OK]

Common Mistakes:

• Passing multiple interfaces separately instead of one
• Using struct instead of interface for behavior
• Ignoring one required method in interface