Composition over Inheritance: Embedding, Interface Composition and Design Patterns

Learning Objectives

Core Concepts

2.1 Embedding: The Cornerstone of Code Reuse

Go has no extends keyword and does not support class inheritance as found in traditional OO languages. Instead it uses embedding. Embedding lets a struct directly contain another struct or interface type, thereby reusing its fields and methods.

What: When struct A embeds struct B, A automatically gains all of B's exported fields and methods. This is called method promotion. Note that embedding is not limited to structs; you can also embed interfaces.

Why this design: Embedding implements composition. Unlike inheritance, composition does not force a tight "is-a" coupling; it establishes a "has-a" relationship. This makes the code more flexible and easier to test and reuse.

How:

type Base struct {
    Name string
}

func (b Base) SayHello() {
    fmt.Println("Hello, I am", b.Name)
}

type Derived struct {
    Base // embed Base
    Age  int
}

In this example, a Derived instance can call SayHello() directly, because Base's method is promoted to Derived.

2.2 Interface Composition and the Smallest Interface Principle

Interface composition merges method sets by embedding other interface types inside an interface. Go has no + syntax; you simply list the embedded interface names.

The smallest interface principle states: interfaces should be as small as possible, containing only the methods the caller really needs. Smaller interfaces are easier to implement and easier to compose.

How:

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

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

// Interface composition: ReadWriter embeds Reader and Writer
type ReadWriter interface {
    Reader
    Writer
}

The method set of ReadWriter is the union of the method sets of Reader and Writer.

2.3 The io.Reader/Writer Composition Pattern

io.Reader and io.Writer are the most fundamental interfaces in the Go standard library. They define the input and output of data streams. By embedding these interfaces we can build richly featured components.

How: For example, io.Pipe returns a PipeReader and a PipeWriter, each implementing io.Reader or io.Writer. We can wrap any io.Reader into a logging Reader simply by embedding the original Reader and overriding the Read method.

Example Code

Example 1: Struct Embedding and Method Promotion

This example shows how to reuse code through embedding and how method promotion works.

package main

import (
    "fmt"
)

// Base defines basic behavior
type Base struct {
    Name string
}

// SayHello is a method of Base
func (b Base) SayHello() {
    fmt.Println("Hello, I am", b.Name)
}

// Derived embeds Base to reuse its fields and methods
type Derived struct {
    Base
    Age int
}

// OverrideSayHello is Derived's own method, coexisting with the promoted SayHello
func (d Derived) OverrideSayHello() {
    fmt.Println("Derived says Hello, I am", d.Name)
}

func main() {
    d := Derived{
        Base: Base{Name: "Alice"},
        Age:  18,
    }

    // call the promoted method
    d.SayHello()
    // call Derived's own method
    d.OverrideSayHello()
}

Expected output:

Hello, I am Alice
Derived says Hello, I am Alice

Example 2: Interface Composition and an io.Reader Wrapper

This example shows interface composition and how to use embedding to build a buffered io.Reader, demonstrating the advantage of programming against interfaces.

package main

import (
    "fmt"
    "io"
    "strings"
)

// BufferedReader embeds io.Reader and implements buffered reading logic
type BufferedReader struct {
    io.Reader
    buffer []byte
    pos    int
}

// NewBufferedReader creates a new BufferedReader
func NewBufferedReader(r io.Reader) *BufferedReader {
    return &BufferedReader{
        Reader: r,
        buffer: make([]byte, 1024),
    }
}

// Read overrides the Read method, showing how to delegate to the embedded Reader
func (br *BufferedReader) Read(p []byte) (n int, err error) {
    // Simplified logic here: delegate directly to the underlying Reader.
    // A real buffered reader is more complex and must handle leftover data in the buffer.
    n, err = br.Reader.Read(p)
    if err != nil && err != io.EOF {
        return n, err
    }
    return n, err
}

func main() {
    // create a string reader
    strReader := strings.NewReader("Hello, Go!")

    // wrap it in a BufferedReader
    br := NewBufferedReader(strReader)

    // read data
    buf := make([]byte, 10)
    n, err := br.Read(buf)
    if err != nil && err != io.EOF {
        fmt.Println("Error:", err)
        return
    }

    fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
}

Expected output:

Read 10 bytes: Hello, Go!

Common Mistakes & Pitfalls

Best Practices

Exercises

1. Concept question: explain what "composition over inheritance" means in Go, and describe how embedding achieves code reuse.
2. Coding exercise: define a LoggingReader struct that embeds io.Reader and overrides the Read method to print a log message "Reading..." before each read.

3. Advanced/debugging exercise: analyze the following code, explain why it does not produce both outputs, and fix it so that it correctly prints "Base Method" and "Derived Method". ```go package main

   import "fmt"

   type Base struct{}

   func (b Base) Method() { fmt.Println("Base Method") }

   type Derived struct { Base }

   func (d Derived) Method() { fmt.Println("Derived Method") }

   func main() { d := Derived{} // Modify this line so that both Derived's and Base's Method are called d.Method() } ```

Reference Answers

package main

import (
    "fmt"
    "io"
    "strings"
)

type LoggingReader struct {
    io.Reader
}

func (lr *LoggingReader) Read(p []byte) (n int, err error) {
    fmt.Println("Reading...")
    return lr.Reader.Read(p)
}

func main() {
    str := strings.NewReader("Hello")
    lr := &LoggingReader{Reader: str}
    buf := make([]byte, 10)
    lr.Read(buf)
}

package main

import "fmt"

type Base struct{}

func (b Base) Method() {
    fmt.Println("Base Method")
}

type Derived struct {
    Base
}

func (d Derived) Method() {
    fmt.Println("Derived Method")
}

func main() {
    d := Derived{}
    d.Method()       // calls Derived's Method
    d.Base.Method()  // calls Base's Method
}

Lesson Summary