What is the difference between Go's implicit and explicit implementation of interfaces?

Question

Jayant Kumar · Accepted Answer

In Go, interfaces can be implicitly or explicitly implemented by a type.
Implicit implementation means that a type satisfies an interface if it has all the methods defined in the interface. In other words, if a type has the same method signatures as an interface, it implicitly implements that interface. Here's an example:
type Speaker interface {
    Speak()
}

type Dog struct {}

func (d Dog) Speak() {
    fmt.Println("Woof!")
}

func main() {
    var s Speaker
    s = Dog{}
    s.Speak() // Output: Woof!
}

In this example, **Dog** implicitly implements the **Speaker** interface because it has a method with the same signature as the **Speak** method in the **Speaker** interface.
Explicit implementation means that a type explicitly declares that it implements an interface by using the interface name in its definition. Here's an example:
type Speaker interface {
    Speak()
}

type Dog struct {}

func (d Dog) Speak() {
    fmt.Println("Woof!")
}

func (d Dog) Bark() {
    fmt.Println("Bark!")
}

func main() {
    var s Speaker
    s = Dog{}
    s.Speak() // Output: Woof!
    // s.Bark() // This will not compile
}

In this example, **Dog** explicitly implements the **Speaker** interface by defining a **Speak** method. The **Bark** method is not part of the interface and cannot be called on a variable of type **Speaker**.
In general, it is recommended to use implicit implementation in Go, as it leads to more flexible and extensible code. Explicit implementation should only be used when necessary, such as when a type needs to implement multiple interfaces with conflicting method signatures.

What is the difference between Go's implicit and explicit implementation of interfaces?

Similar Questions

What is the difference between Go's implicit and explicit implementation of interfaces?

Jayant Kumar @jayantkumar314

Similar Questions