Detailed explanation of the use of interface types in Go language

Go language is a statically typed language, which forces the type of each variable, function parameter and return value to be determined at compile time. Therefore, in Go language, type management of function parameters and return values ​​is particularly important.

In actual development, we often encounter situations where we need to convert certain types of data into another type of data. Therefore, the Go language provides an interface type, which can be used to represent any type of data, that is, convert different types of data into the same type of data.

Below, we will introduce how to use the interface type in the Go language and how to convert other types of data into interface type data.

1. Definition of interface type in Go language

In Go language, interface type is an abstract type. It is a set of method signatures. As long as a certain If a type implements these methods, it belongs to the interface type.

To define an interface type method in Go language, you need to use the interface keyword. The following is the complete definition of the interface type:

type interface_name interface {
    method_name1 [return_type]
    method_name2 [return_type]
    method_name3 [return_type]
    ...
    method_namen [return_type]
}

Among them, interface_name represents the defined interface name. method_name represents the method name in the interface. If the method has a return value, the return value type needs to be added. It is important to note here that the methods defined by the interface do not need to be implemented, but the method signature needs to be defined in the interface type.

2. Implementation of interface type in Go language

To implement a variable of an interface type in Go language, you only need to implement all methods in the interface. For example, the following code implements a simple interface:

type student struct {
    name string
    age  int
}

type studentInterface interface {
    GetName() string
    GetAge()  int
}

func (s student) GetName() string {
    return s.name
}

func (s student) GetAge() int {
    return s.age
}

func main() {
    stu := student{"John", 18}
    var varStu studentInterface = stu

    fmt.Println(varStu.GetName())
    fmt.Println(varStu.GetAge())
}

In the above code, we implement an interface studentInterface, which defines two methods, GetName and GetAge. At the same time, we also defined a struct type student, which contains two fields: name and age.

During the interface implementation process, we implemented the variable varStu of the studentInterface type by defining a variable stu of the student type. By calling the GetName and GetAge methods of the varStu object, we can obtain the name and age field values ​​​​in the stu object.

It should be noted that when implementing an interface type, the implemented method needs to be defined on the type implemented by the interface. For example, in the above code, we define the two methods GetName and GetAge on the student type.

3. Convert other types in Go language to interface type

In Go language, we can convert other types of data into interface type data. During the conversion process, we can assign a specific type to the empty interface type through assignment, thereby converting this type of data into interface type data.

// 通过实现Stringer接口将自定义类型转化为interface类型
type People struct {
    name string
    age int
}

func (p People) String() string {
    return fmt.Sprintf("%v (%v years)", p.name, p.age)
}

func main() {
    john := People{"John", 18}
    fmt.Println(john)

    var varObj interface{}
    varObj = john

    fmt.Printf("varObj is: %v\n", varObj)
}

In the above code, we first define a custom type People, including two fields: name and age. We convert this type into the interface type by implementing the method Stringer, and then convert the People type variable john into the interface type variable varObj.

Summary

In this article, we briefly introduce the definition and implementation of the interface type in the Go language, and how to convert other types of data into interface type data. The interface type is one of the very important features of the Go language. It can help us implement more flexible and versatile code logic.

The above is the detailed content of Detailed explanation of the use of interface types in Go language. For more information, please follow other related articles on the PHP Chinese website!