interfaces

Question 1

Interface Basics

Answer 1

type Speaker interface {
    Speak() string
}

Key Points:
* Named collection of method signatures
* Types implicitly satisfy interfaces by implementing all methods
* Zero value: nil

Question 2

Implicit Implementation

Answer 2

type Dog struct{}
func (d Dog) Speak() string { return "Woof!" }

var s Speaker = Dog{}  // Dog satisfies Speaker
fmt.Println(s.Speak()) // "Woof!"

Rule: No explicit implements keyword - satisfaction is automatic.

Question 3

Empty Interface (interface{})

Answer 3

Use Case: Accept any type

func logAnything(v interface{}) {
    fmt.Printf("%T: %v\n", v, v)
}
logAnything(42)       // int: 42
logAnything("hello")  // string: hello

Question 4

Type Assertions

Answer 4

Check Concrete Type:

var s Speaker = Dog{}
dog := s.(Dog)  // Extract Dog

Safe Check:

if dog, ok := s.(Dog); ok {
    fmt.Println(dog.Speak())
}

Question 5

Type Switches

Answer 5

Handle Multiple Types:

func describe(i interface{}) {
    switch v := i.(type) {
    case Dog:
        fmt.Println("Dog says:", v.Speak())
    case int:
        fmt.Println("Integer:", v)
    default:
        fmt.Printf("Unknown type %T\n", v)
    }
}

Question 6

Common Interfaces

Answer 6

Built-in Examples:

type error interface { Error() string }
type Stringer interface { String() string }

Usage:

func (d Dog) String() string { return "I'm a dog" }
fmt.Println(Dog{}) // Calls String() automatically

Question 7

Interface Values

Answer 7

Under the Hood:
* Dynamic type + value (or nil)

var s Speaker  // nil interface
s = Dog{}      // type=Dog, value=Dog{}

Nil vs Nil Interface:

var d *Dog     // nil concrete value
var s Speaker = d  // s != nil (has type *Dog)

Question 8

Best Practices

Answer 8

1. Keep interfaces small (1-3 methods)
2. Name interfaces with -er suffixes (Reader, Writer)
3. Compose interfaces:

type ReadWriter interface {
    Reader
    Writer
}

Question 9

Interface Pitfalls

Answer 9

Watch For:
* Nil pointer dereference:

var s Speaker
s.Speak()  // PANIC: nil interface

Accidental shadowing:
var _ io.Writer = (*bytes.Buffer)(nil) // Compile-time check

Question 10

Real-World Examples

Answer 10

HTTP Handler:

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

Sorting:

sort.Interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

Key Insight: Interfaces enable polymorphism and dependency injection in Go.