Interface Basics

Interfaces are Go's way of defining behavior. They enable polymorphism without inheritance, making code flexible and testable. In this lesson, you'll learn how interfaces work, how to define them, and how to use them effectively.

What is an Interface?

An interface is a collection of method signatures. Any type that implements all the methods automatically satisfies the interface:

Click Run to execute your code

Interface Syntax

type InterfaceName interface {
    Method1(param type) returnType
    Method2(param type) returnType
    // ... more methods
}

Implicit Implementation

Go doesn't require explicit declaration of interface implementation:

Click Run to execute your code

Figure: Interfaces and Polymorphism - How different types (Circle, Rectangle) can satisfy the same interface (Shape)

Interface Values

An interface value holds a value of a specific type:

var s Shape
s = Circle{Radius: 5}    // s holds a Circle
s = Rectangle{W: 3, H: 4} // s now holds a Rectangle

// Interface value has two components:
// 1. Concrete type (Circle or Rectangle)
// 2. Concrete value (the actual data)

Nil Interface Values

var s Shape  // nil interface (both type and value are nil)

// Calling method on nil interface panics
s.Area()  // panic!

// Check for nil
if s != nil {
    s.Area()
}

The Empty Interface

The empty interface interface{} can hold values of any type:

Click Run to execute your code

Interface Composition

Interfaces can be composed from other interfaces:

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

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Closer interface {
    Close() error
}

// Composed interface
type ReadWriter interface {
    Reader
    Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

Practical Interface Patterns

1. Dependency Injection

// Define interface for what you need
type DataStore interface {
    Save(data string) error
    Load() (string, error)
}

// Business logic depends on interface
type Service struct {
    store DataStore
}

func (s *Service) Process(data string) error {
    return s.store.Save(data)
}

// Different implementations
type FileStore struct { /* ... */ }
func (f *FileStore) Save(data string) error { /* ... */ }
func (f *FileStore) Load() (string, error) { /* ... */ }

type MemoryStore struct { /* ... */ }
func (m *MemoryStore) Save(data string) error { /* ... */ }
func (m *MemoryStore) Load() (string, error) { /* ... */ }

2. Testing with Mocks

// Production code
type EmailSender interface {
    Send(to, subject, body string) error
}

type UserService struct {
    emailer EmailSender
}

// Test code
type MockEmailer struct {
    sentEmails []string
}

func (m *MockEmailer) Send(to, subject, body string) error {
    m.sentEmails = append(m.sentEmails, to)
    return nil
}

// Test
func TestUserService(t *testing.T) {
    mock := &MockEmailer{}
    service := UserService{emailer: mock}
    // Test without sending real emails!
}

Common Mistakes

// ❌ Wrong - unnecessary interface
type UserGetter interface {
    GetUser(id int) User
}

type UserService struct{}
func (s *UserService) GetUser(id int) User { /* ... */ }

// Only one implementation? Don't need interface!

// ✅ Correct - use concrete type
type UserService struct{}
func (s *UserService) GetUser(id int) User { /* ... */ }

// Create interface only when you need abstraction

type Printer interface {
    Print()
}

type Document struct {
    content string
}

// Pointer receiver
func (d *Document) Print() {
    fmt.Println(d.content)
}

// ❌ Wrong - value doesn't satisfy interface
var p Printer = Document{content: "test"}  // Error!

// ✅ Correct - use pointer
var p Printer = &Document{content: "test"}  // OK

// ❌ Less flexible
func NewUserService() *UserService {
    return &UserService{}
}

// ✅ Better - return interface
type UserStore interface {
    GetUser(id int) User
}

func NewUserService() UserStore {
    return &UserService{}
}
// Callers depend on interface, not concrete type

Exercise: Payment Processor

package main

import (
    "fmt"
)

// PaymentMethod interface
type PaymentMethod interface {
    Pay(amount float64) error
}

// CreditCard implementation
type CreditCard struct {
    Number string
    Name   string
}

func (c CreditCard) Pay(amount float64) error {
    fmt.Printf("Charging $%.2f to credit card %s\n", amount, c.Number)
    return nil
}

// PayPal implementation
type PayPal struct {
    Email string
}

func (p PayPal) Pay(amount float64) error {
    fmt.Printf("Charging $%.2f to PayPal account %s\n", amount, p.Email)
    return nil
}

// Bitcoin implementation (bonus)
type Bitcoin struct {
    WalletAddress string
}

func (b Bitcoin) Pay(amount float64) error {
    fmt.Printf("Sending $%.2f worth of Bitcoin to %s\n", amount, b.WalletAddress)
    return nil
}

// Process payment using any payment method
func processPayment(method PaymentMethod, amount float64) error {
    fmt.Printf("Processing payment of $%.2f...\n", amount)
    return method.Pay(amount)
}

func main() {
    // Test with different payment methods
    cc := CreditCard{
        Number: "**** **** **** 1234",
        Name:   "Alice Smith",
    }
    
    pp := PayPal{
        Email: "[email protected]",
    }
    
    btc := Bitcoin{
        WalletAddress: "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
    }
    
    // Process payments
    processPayment(cc, 99.99)
    fmt.Println()
    processPayment(pp, 49.99)
    fmt.Println()
    processPayment(btc, 199.99)
}

Summary

What's Next?

Now that you understand interface basics, you're ready to learn about Type Switches & Common Interfaces. You'll discover how to work with interface values at runtime and explore Go's standard library interfaces.