Handling Backward Compatibility with Interfaces in Go

package main

import "fmt"

// Flyer interface defines a method CanFly.
type Flyer interface {
    CanFly() string
}

// Sparrow implements the Flyer interface.
type Sparrow struct{}

func (s Sparrow) CanFly() string {
    return "Yes, I can fly!"
}

// Penguin implements the Flyer interface differently.
type Penguin struct{}

func (p Penguin) CanFly() string {
    return "No, I prefer swimming."
}

func main() {
    var flyer Flyer

    sparrow := Sparrow{}
    penguin := Penguin{}

    flyer = sparrow
    fmt.Println("Sparrow says: " + flyer.CanFly()) // Output: "Yes, I can fly!"

    flyer = penguin
    fmt.Println("Penguin says: " + flyer.CanFly()) // Output: "No, I prefer swimming."
}

package main

import "fmt"

// MathOperations interface with Multiply method.
type MathOperations interface {
    Multiply(a, b int) int
}

// BasicMath is a basic implementation of MathOperations.
type BasicMath struct{}

func (bm BasicMath) Multiply(a, b int) int {
    return a * b
}

// ExtendedMath includes the basic Multiply method and extends it.
type ExtendedMath struct {
    BasicMath
}

func (em ExtendedMath) MultiplyExtended(a, b, c int) int {
    return a * b * c
}

func main() {
    basic := BasicMath{}
    fmt.Println(basic.Multiply(2, 3)) // Output: 6

    extended := ExtendedMath{}
    fmt.Println(extended.Multiply(2, 3))          // Output: 6
    fmt.Println(extended.MultiplyExtended(2, 3, 4))       // Output: 24
}