Golang interface classic writing method

Golang is a relatively young programming language. Although it is a static language, its powerful interface features allow it to flexibly respond to various needs. In this article, we will introduce some classic writing methods of Golang interfaces and their application scenarios, hoping to help readers better understand and use Golang interfaces.

Interface definition

The interface in Golang, like other object-oriented languages, defines a set of methods. As long as a type implements some of the methods, it is considered to implement the interface. This implementation method is somewhat similar to the concept of inheritance in other languages. The interface definition in Golang is as follows:

type 接口名 interface {
    方法名1(参数列表) 返回值类型
    方法名2(参数列表) 返回值类型
    ...
}

Among them, the interface name is a description of the interface, the method name is the name of the method defined in the interface, and the parameter list is the type and name of the parameters used by the method. , the return value type is the return value type of the method. It should be noted that in Golang, an interface can define zero to multiple methods.

Interface implementation

In Golang, the implementation of interfaces is implemented through structures. If a type wants to implement an interface, it only needs to define a method set for the type. This method set includes the type's implementation of all methods in the interface. The method set is defined as follows:

type 实现接口的类型 struct {
    //类型的字段
}

// 实现接口中定义的方法
func (r 实现接口的类型) 方法名1(参数列表) 返回值类型 {
    // 方法的实现
}

func (r 实现接口的类型) 方法名2(参数列表) 返回值类型 {
    // 方法的实现
}
...

It should be noted that the type that implements the interface must provide the implementation of the method defined in the corresponding interface, otherwise an error will be reported during compilation. Below we will introduce some classic interface implementation methods.

1. Interface layering

In project development, there are often application scenarios with multi-level interfaces. In this case, interface layering can be used to implement it. The principle of interface layering is: each interface only cares about the interface it calls, and defines the same methods in the same level. The specific implementation method is as follows:

// 接口定义：层1
type IOutputer interface {
    Output(data []byte) error
}

// 接口定义：层2
type ILogger interface {
    Start()
    Stop()
}

// 实现层2接口
type FileLogger struct {
    logFilePath string
}

func (l *FileLogger) Start() {
    ...
}

func (l *FileLogger) Stop() {
    ...
}

// 实现层1接口
func (l *FileLogger) Output(data []byte) error {
    ...
}

In this way, we will It is divided into two layers, and each layer only cares about its own method implementation, thus better achieving the purpose of module decoupling and reuse.

2. Empty interface

In Golang, interface{} is an empty interface, because it defines an empty method set and has maximum applicability and flexibility. Therefore, an empty interface can represent any type of value. Usually, when we need to deal with different types, we can use the empty interface to perform type conversion or operate on data. For example, if the parameter in the interface method is a variable of type interface{}, then any type of variable can be passed in for processing. Its implementation is as follows:

// 定义处理数据的函数
func processData(data interface{}) {
    ...
}

// 在调用时将数据转换为interface{}类型
var data interface{} = "Hello Golang"
processData(data)

The empty interface ensures the flexibility of Golang, but you need to pay attention to the correctness of type conversion during use.

3. Polymorphism

In object-oriented programming, polymorphism is a very important concept. The implementation of polymorphism is based on the characteristics of interfaces, that is, the same instance shows different behaviors at different times. In Golang, the interface-based polymorphic implementation is relatively simple, and the specific implementation is as follows:

type Cat struct {}

func (c *Cat) say() {
    fmt.Println("喵喵喵")
}

type Dog struct {}

func (d *Dog) say() {
    fmt.Println("汪汪汪")
}

// 定义接口
type Animal interface {
    say()
}

func main() {
    var cat Animal = new(Cat) // 实例化Cat
    var dog Animal = new(Dog) // 实例化Dog

    cat.say() // 调用Cat的say方法
    dog.say() // 调用Dog的say方法
}

Through polymorphic implementation, we can write more flexible code, and it also facilitates code maintenance and expansion.

4. Assertion

In development, we often need to assert a type to determine its actual type. In Golang, we can use the type assertion mechanism to implement type assertions. It is implemented as follows:

var a interface{} = "Hello Golang"
str := a.(string)
fmt.Println(str)

In the above code, we use the assertion mechanism. First, we assign a variable of type interface{} to "Hello Golang", and then get a string type through assertion. variable str. It should be noted that in actual use, you need to pay attention to the correctness of the type when asserting, otherwise runtime errors will occur.

Summary

Through the introduction of this article, I believe that everyone has a deeper understanding of the application of interfaces in Golang. In actual development, different scenarios often require different interface implementation methods. We need to analyze specific problems to achieve the best results. Here we emphasize again that mastering the concept of interface will play a very important role in the development of Golang.

The above is the detailed content of Golang interface classic writing method. For more information, please follow other related articles on the PHP Chinese website!