Structs and Methods: The Foundation of Go OOP

Learning Objectives

Core Concepts

2.1 Struct Definition and Initialization

What Go has no class keyword; instead it uses type and struct to define composite data types. A struct consists of a series of fields, each with a name and a type.

Why Go's design philosophy is "composition over inheritance". Structs are the basic building blocks for complex data models; compared with classes, they are lighter and have clearer semantics.

How Use the type keyword to define a new type, and struct to describe the field layout. For initialization, prefer struct literals with named fields, which are safer.

type Point struct {
    X, Y float64
}

// Initialize with a struct literal
p := Point{X: 1.0, Y: 2.0}

2.2 Anonymous Fields and Embedding Promotion

What A struct field can be anonymous (i.e. only a type, no field name). When the type of an anonymous field is another struct, this is called embedding. The embedded fields and methods are "promoted" to the outer struct and can be accessed directly through the outer instance.

Why Embedding provides a code-reuse mechanism that is more flexible than traditional inheritance. It avoids namespace pollution while letting the outer struct override or extend the inner behavior.

How Write the type name directly in the struct definition. When accessing a promoted member, the compiler looks in the outer struct first, then the inner one. If a same-named member appears at the same depth, the selector is ambiguous and must be disambiguated explicitly.

type Base struct {
    ID int
}

type Derived struct {
    Base // embed Base
    Name string
}

d := Derived{Base: Base{ID: 1}, Name: "test"}
fmt.Println(d.ID) // access the promoted field

2.3 Methods and Method Sets

What A method is a function bound to a specific type. In Go, methods are defined on types, not inside classes. Every type has a method set that defines all the methods it owns.

Why The method set is the core mechanism by which Go implements interfaces. Whether a type satisfies an interface depends on whether its method set contains all the methods the interface requires.

How Define a method with the syntax func (r ReceiverType) MethodName(args) returnType.

2.4 Value Receivers and Pointer Receivers

What - Value receiver: the method receives a copy of the type. Modifying fields inside the method does not affect the original instance. - Pointer receiver: the method receives a pointer to the type. Modifying fields inside the method directly affects the original instance.

Why - Performance: large structs should use a pointer receiver to avoid copy overhead. - Semantics: a method that needs to modify state must use a pointer receiver. - Consistency: if a type has both value-receiver and pointer-receiver methods, watch out for the difference in method sets.

How - If the type is small (primitive types, small structs) and the method does not modify state, prefer a value receiver. - If the type is large or the method needs to modify state, use a pointer receiver. - Key rule: the method set of *T includes all methods of both T and *T; the method set of T includes only the methods of T. Therefore, a variable of type T can call a method with a *T receiver (the compiler automatically takes its address), but a variable of type *T cannot call a method with a T receiver unless you explicitly dereference.

Example Code

Example 1: Struct Embedding and Method Promotion

This example demonstrates struct embedding, field promotion and method calls.

package main

import "fmt"

type Logger struct {
    Prefix string
}

func (l Logger) Log(msg string) {
    fmt.Printf("[%s] %s\n", l.Prefix, msg)
}

type Service struct {
    Logger       // embed Logger
    ServiceName string
}

func (s Service) Start() {
    s.Log("Starting service...") // call the promoted method
}

func main() {
    svc := Service{
        Logger:      Logger{Prefix: "INFO"},
        ServiceName: "MyService",
    }
    svc.Start()
}

Expected output:

[INFO] Starting service...

Example 2: Method-Set Differences Between Value and Pointer Receivers

This example shows the difference between value and pointer receivers in implementing an interface, and the call rules for pointer-receiver methods.

package main

import "fmt"

type Counter struct {
    Count int
}

// A value-receiver method
func (c Counter) Inc() {
    c.Count++
}

// A pointer-receiver method
func (c *Counter) Dec() {
    c.Count--
}

func main() {
    c := Counter{Count: 10}

    // Call the value-receiver method through a value
    c.Inc()
    fmt.Println("After Inc:", c.Count) // 11 (note: c is not modified here because Inc has a value receiver,
                                       // but c is a local variable; this line demonstrates the method's behavior)

    // Correction: to demonstrate the pointer receiver, we need an addressable variable.
    // In fact, c.Inc() does not change c.Count, because the receiver is a value.
    // Let's redesign it to show the difference clearly.

    c2 := Counter{Count: 10}
    c2.Inc() // the copy is incremented, the original is unchanged
    fmt.Println("c2 after Inc:", c2.Count) // 10

    // A pointer-receiver method
    c3 := &Counter{Count: 10}
    c3.Dec() // the value the pointer points to is decremented
    fmt.Println("c3 after Dec:", c3.Count) // 9

    // A value variable calling a pointer-receiver method (auto address)
    c4 := Counter{Count: 10}
    (&c4).Dec() // explicit address
    fmt.Println("c4 after Dec:", c4.Count) // 9
}

Expected output:

c2 after Inc: 10
c3 after Dec: 9
c4 after Dec: 9

Common Mistakes & Pitfalls

Best Practices

Exercises

1. Concept question: explain why the method set of *T includes all the methods of T, while the method set of T does not include the methods of *T.
2. Coding exercise: define a Rectangle struct with Width and Height. Define a Scale method that multiplies both width and height by factor. Verify it in main.
3. Advanced/debugging exercise: the code below has an error. Find it and fix it.

package main

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

type Cylinder struct {
    Circle
    Height float64
}

func (c *Cylinder) Volume() float64 {
    return c.Area() * c.Height
}

func main() {
    var s Shape = Cylinder{Radius: 10, Height: 20}
    fmt.Println("Area:", s.Area())
}

Reference Answers

package main

import "fmt"

type Rectangle struct {
    Width  float64
    Height float64
}

func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

func main() {
    r := Rectangle{Width: 10, Height: 20}
    r.Scale(2)
    fmt.Printf("Width: %.2f, Height: %.2f\n", r.Width, r.Height)
}

package main

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

// Changed to a pointer receiver
func (c *Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

type Cylinder struct {
    Circle
    Height float64
}

func (c *Cylinder) Volume() float64 {
    return c.Area() * c.Height
}

func main() {
    // You must use the pointer type to satisfy the Shape interface,
    // because Area is now a pointer receiver.
    var s Shape = &Cylinder{Radius: 10, Height: 20}
    fmt.Println("Area:", s.Area())
}

Lesson Summary