Simulating Method Override in Go with Interfaces, Embedding, and Functional Options

Why Go Has No Override Keyword

Go deliberately omits class inheritance and the override keyword. Instead, it offers three powerful mechanisms: interfaces to define contracts, struct embedding to reuse fields and methods, and functional options to customize behavior at runtime.

Step 1: Define an Interface (the "hot water")

type Animal interface {
    Speak() string
    Run() string
}

The Animal interface declares what actions a type must support, without caring about the concrete implementation.

Step 2: Basic Implementation and Embedding (the "soap")

type Dog struct {}

func (d Dog) Speak() string { return "汪！" }
func (d Dog) Run() string   { return "🐶 撒腿狂奔！" }

type Husky struct {
    Dog // embedding, not inheritance
}

func (h Husky) Speak() string { return "嗷呜～❄️ 雪橇呢？我拆了？" }

Embedding Dog gives Husky access to Dog 's Run method automatically, while Husky provides its own Speak implementation, achieving a shadowing effect similar to overriding.

Step 3: Add Functional Options for Runtime Customisation (the "shampoo")

type Husky struct {
    Dog
    speakMode string // "naughty" or "good"
}

type HuskyOption func(*Husky)

func WithNaughtyMode() HuskyOption {
    return func(h *Husky) { h.speakMode = "naughty" }
}

func WithGoodBoyMode() HuskyOption {
    return func(h *Husky) { h.speakMode = "good" }
}

func NewHusky(opts ...HuskyOption) *Husky {
    h := &Husky{Dog: Dog{}, speakMode: "good"}
    for _, opt := range opts { opt(h) }
    return h
}

func (h *Husky) Speak() string {
    switch h.speakMode {
    case "naughty":
        return "💥轰隆！墙呢？我的玩具呢？？"
    default:
        return "🥺摇尾巴…（其实爪子在刨沙发）"
    }
}

The constructor NewHusky applies any supplied options, allowing callers to decide at runtime whether the husky behaves "naughty" or "good".

Putting It All Together

func main() {
    var a Animal = Dog{}
    fmt.Println(a.Speak(), a.Run()) // 汪！, 🐶 撒腿狂奔！

    h1 := NewHusky() // default good mode
    fmt.Println(h1.Speak()) // 🥺摇尾巴…

    h2 := NewHusky(WithNaughtyMode())
    fmt.Println(h2.Speak()) // 💥轰隆！墙呢？我的玩具呢？？
}

This demo prints the dog’s default behavior, then shows the husky in both default (good) and naughty modes.

Comparison with Java‑Style Override

Core mechanism : Java uses inheritance + @Override; Go uses embedding + interface + method shadowing.

Flexibility : Java’s implementation is fixed at compile time; Go can customise at runtime via functional options.

Coupling : Java creates a deep inheritance chain (high coupling); Go’s composition keeps coupling low.

Readability : In Java you must trace the inheritance hierarchy to find the overridden method; in Go the method lives directly on the struct, making it obvious.

Conclusion

Go does not provide a traditional override keyword, but by combining interfaces, struct embedding, and functional options you can achieve the same effect with better decoupling, testability, and runtime flexibility. The pattern feels like a "clean shower" for your code: gentle, customizable, and free of the "dry‑code" bugs that inheritance can cause.