Exercise 2: Interfaces and Polymorphism in Go

An interface in Go defines a behavior that a type must implement. Unlike other languages, Go does not use an `implements` keyword.

type Animal interface {
    Speak() string
}

• Flexibility: Allows defining behavior without worrying about specific types.
• Polymorphism: A function can accept multiple different types as long as they implement the same interface.
• Modularity: Makes code more reusable and adaptable.

• Java: Uses `implements` to explicitly declare that a class implements an interface.
• Python: Uses abstract classes and duck typing.
• C++: Interfaces are often handled via abstract classes.

• Create a file interfaces.go
• Define an interface `Animal` with a method `Speak()`.
• Create two structures `Dog` and `Cat` that implement this interface.
• Implement the `Speak()` method for each type.
• Test using a function that prints each animal's sound.

package main

import "fmt"

type Animal interface {
    Speak() string
}

type Dog struct {}
type Cat struct {}

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

func (c Cat) Speak() string {
    return "Meow!"
}

func MakeSound(a Animal) {
    fmt.Println(a.Speak())
}

func main() {
    dog := Dog{}
    cat := Cat{}
    
    MakeSound(dog)
    MakeSound(cat)
}

Woof!
Meow!