How Can Type Composition Streamline Method Implementation in Go?

Golang: Embracing Type Composition for Unified Method Implementation

In object-oriented programming, sometimes different structs may share a common field or functionality. To handle such scenarios, a common practice is to define an interface that both structs implement. However, this approach requires defining separate methods for each struct, leading to code duplication.

A more efficient approach is to leverage the principle of type composition. Instead of using interfaces, we can define a custom type representing the shared field (e.g., Version in the provided example). Since custom types can serve as method receivers, we can create a method for this type and then embed it within both structs.

Consider the following implementation:

<code class="go">type Version string

func (v Version) PrintVersion() {
    fmt.Println("Version is", v)
}

type Game struct {
    Name               string
    MultiplayerSupport bool
    Genre              string
    Version            Version
}

type ERP struct {
    Name               string
    MRPSupport         bool
    SupportedDatabases []string
    Version            Version
}</code>

Now, we can use the PrintVersion method on both Game and ERP structs:

<code class="go">func main() {

    g := Game{
        "Fear Effect",
        false,
        "Action-Adventure",
        "1.0.0",
    }

    g.PrintVersion()
    // Version is 1.0.0


    e := ERP{
        "Logo",
        true,
        []string{"ms-sql"},
        "2.0.0",
    }

    e.PrintVersion()
    // Version is 2.0.0

}</code>

This approach eliminates code duplication and provides a unified way to print the version for both structs. Moreover, it can be extended to handle other common fields or functionalities.

The above is the detailed content of How Can Type Composition Streamline Method Implementation in Go?. For more information, please follow other related articles on the PHP Chinese website!