How Can Interfaces in Go Be Used to Implement Methods for Different Types Without Code Duplication?

Implementing Methods for Different Types Using Interfaces in Go

In Go, interfaces provide a mechanism to define a set of methods that various types can implement. This allows for polymorphic behavior, where different types can share a common set of operations.

Problem Statement

Suppose we have two structs, First and Second, that we want to make implement an interface, A, which defines a method called PrintStr(). Each struct has a string field named str. However, if we implement the PrintStr() method separately for both structs, it becomes redundant.

Proposed Solution

One might think it's possible to have a single implementation of PrintStr() for both structs by defining it on the A interface itself. However, this approach doesn't work because interfaces do not carry any data.

Embedding and Implementing

Instead of a single implementation on the interface, we can create a base type, WithString, and embed it into both First and Second. The WithString type will have the str field and implement the PrintStr() method. By embedding WithString, both First and Second indirectly gain the str field and the PrintStr() implementation. This allows them to implement the A interface with minimal duplication.

Example Code

type WithString struct {
    str string
}

type First struct {
    WithString
}

type Second struct {
    WithString
}

type A interface {
    PrintStr() //print First.str or Second.str
}

func (w WithString) PrintStr() {
    fmt.Print(w.str)
}

Usage

a := First{
    WithString: WithString{
        str: "foo",
    },
}

This approach allows us to implement a common method for different types while avoiding code duplication.

The above is the detailed content of How Can Interfaces in Go Be Used to Implement Methods for Different Types Without Code Duplication?. For more information, please follow other related articles on the PHP Chinese website!