golang interface default implementation

In order to make the code more flexible and scalable, it is often necessary to use interfaces for development. In Go language, interface is a very powerful language feature that supports multiple structures to implement the same interface.

However, in the past, the Go language did not support the default implementation of interfaces, which meant that when implementing an interface, all methods of the interface must be implemented. When you need to inherit an interface, you need to implement the same method over and over in the sub-interface, which results in a high degree of code duplication and is not conducive to code expansion and maintenance.

In order to solve this problem, starting from Go language version 1.8, support for the default implementation of the interface is provided. This feature allows us to define default implementations of methods in the interface, so that only the necessary methods need to be implemented when implementing the interface.

The syntax of the default implementation of the interface

The syntax of the default implementation of the interface is very simple. You only need to add the default keyword before the method implementation. For example:

type Reader interface {

Read(p []byte) (n int, err error)
default Close() error {
    return nil
}

}

In this example, the Reader interface defines the Read method and a default implementation of the Close method. If the Reader interface is implemented but the Close method is not implemented, the system will use the default Close method.

It should be noted that if an interface defines a default implementation method, then you only need to implement the non-default method when implementing the interface. If you want to override the default implementation method, you can define a method with the same name in the structure that implements the interface to replace the default implementation.

Application scenarios for the default implementation of the interface

The usage scenarios for the default implementation of the interface are very wide. Below we will introduce several common application scenarios.

1. Interface nesting

In the Go language, interface nesting is a very common technology. Nested interfaces can make the code more flexible and better organized.

Suppose we have an interface that needs to read and write files:

type FileReadWrite interface {

Read(p []byte) (n int, err error)
Write(p []byte) (n int, err error)

}

Next we define an interface that needs to close the file ：

type Closeable interface {

Close() error

}

If we want to define a file operation interface, including reading, writing and closing file methods, we can use the nested interface Method:

type FileOperation interface {

FileReadWrite
Closeable

}

Using the default implementation can avoid repeatedly implementing the Close method when implementing the FileOperation interface.

2. Interface version upgrade

During the development process, interface version upgrades are often encountered. When we need to add methods to an interface, if we modify the original interface directly, all code that has implemented the interface will need to be modified.

By using the default implementation, we can add new methods to the interface without breaking the existing code. If you need to use a new method, you can override the default implementation method in the structure that implements the interface.

3. Adapter pattern of interface

The adapter pattern is a common design pattern used to convert the interface of a class into another interface to facilitate the unsupported Interaction between classes of this interface.

In the Go language, we can use the interface default implementation to quickly implement the adapter pattern. Here is a simple example:

type USB interface {

Connect()
DataTransfer(data string) string

}

type Adaptee struct {}

func (a *Adaptee) OldInterface( ) {

fmt.Println("support old interface")

}

type Adapter interface {

USB

}

type AdapterImpl struct {

Adaptee

}

func (a *AdapterImpl) Connect() {

fmt.Println("connect USB")

}

func (a *AdapterImpl) DataTransfer(data string) string {

fmt.Println("transfer data through USB")
a.OldInterface()  
return "Result"

}

In this example, we define a USB interface and an old interface Adaptee to demonstrate the use of the adapter. In order to enable Adaptee to use the USB interface, we define an adapter that implements the Adapter interface.

Connect and DataTransfer in the adapter use the default implementation. The OldInterface method of Adaptee is called in the default implementation. In this way, we can use an adapter to convert a class that does not support the USB interface into a class that supports the USB interface.

Summary

The default implementation of interfaces in Go language is a very practical language feature. It allows us to define interfaces more flexibly, while reducing code duplication and improving code quality. Through the use of interface default implementation, we can more easily implement design patterns such as reuse and adapter pattern.

The above is the detailed content of golang interface default implementation. For more information, please follow other related articles on the PHP Chinese website!