golang interface query

Golang, also known as Go language, is an open source, compiled system-level programming language. Compared with other programming languages, Golang has higher concurrency and stronger memory safety, so it has been widely used in Internet applications. In Golang, interface is a very important concept, it is the core mechanism to achieve polymorphism. This article will introduce the relevant content of interface query in Golang.

1. First introduction to interfaces

1. The concept of interface

In Golang, an interface is a type that defines the behavior specification of an object. That is, it specifies which methods the object should have. An interface is an abstract concept that itself has no practical meaning. It just defines a set of methods that are implemented by the type that implements the interface. In Golang, the type that implements the interface needs to implement all methods defined in the interface, otherwise compilation errors will occur.

2. The role of interface

Interface is the mechanism to achieve polymorphism in Golang. By using interfaces, objects of different types can be treated as the same type, thereby achieving unified processing of objects. In Golang, interfaces can also be used to implement functions such as dependency injection and type conversion.

3. Definition of interface

In Golang, you can use the type keyword to define an interface type. The interface is defined as follows:

type interface_name interface {
    method_name1(parameters_list) return_value_list
    method_name2(parameters_list) return_value_list
    ...
}

In the interface definition, each method consists of a method name, a parameter list, and a return value list. Among them, the parameter list and return value list can be multiple parameters. If the method has no return value, the return value list can be omitted.

2. Interface query

1. The concept of interface query

Interface query refers to determining whether an object implements a certain interface during program running and How to use the methods of this object. In Golang, you can use type assertions and type judgments to perform interface queries.

2. Type assertion

Type assertion refers to determining whether an object is of a certain type when the program is running, and converting it to that type. In Golang, you can use the following method for type assertion:

value, ok := object.(type_name)

where object represents the object that needs to be typed, and type_name represents the type that needs to be converted. If object is an object of type_name type, value represents the converted object, and ok is true; otherwise, value is nil, and ok is false.

3. Type judgment

Type judgment refers to judging whether an object implements a certain interface when the program is running. In Golang, the following method can be used for type judgment:

_, ok := object.(interface_name)

Among them, object represents the object that needs to be judged, and interface_name represents the interface that needs to be implemented. If the object implements the interface_name interface, ok is true; otherwise, ok is false.

3. Example Demonstration

The following uses an example to demonstrate the use of interface query.

1. Create interface

First, we need to create an interface Animal to define the behavior specifications of animals. The definition of the Animal interface is as follows:

type Animal interface {
    Eat(food string) string
    Sleep() string
}

In the Animal interface, two methods Eat and Sleep are defined to represent the behavior of animals eating and sleeping.

2. Create implementation classes

Next, we need to create two implementation classes Cat and Dog to implement the methods defined in the Animal interface. The Cat and Dog classes are defined as follows:

type Cat struct{}

func (c *Cat) Eat(food string) string {
    return fmt.Sprintf("Cat is eating %s", food)
}

func (c *Cat) Sleep() string {
    return "Cat is sleeping"
}

type Dog struct{}

func (d *Dog) Eat(food string) string {
    return fmt.Sprintf("Dog is eating %s", food)
}

func (d *Dog) Sleep() string {
    return "Dog is sleeping"
}

In the Cat and Dog classes, the two methods Eat and Sleep defined in the Animal interface are implemented respectively.

3. Test interface query

Finally, we need to test the interface query function to determine whether the Cat and Dog objects implement the Animal interface. The test code is as follows:

func main() {
    var animal Animal

    cat := &Cat{}
    if _, ok := cat.(Animal); ok {
        fmt.Println("cat implements Animal interface")
        animal = cat
    }

    dog := &Dog{}
    if _, ok := dog.(Animal); ok {
        fmt.Println("dog implements Animal interface")
        animal = dog
    }

    fmt.Println(animal.Eat("meat"))
    fmt.Println(animal.Sleep())
}

In the test code, first create the variable animal to store objects that implement the Animal interface. Then, Cat and Dog objects are created respectively, and type judgment is used to determine whether they implement the Animal interface. Finally, call the Eat and Sleep methods of the animal object for testing.

4. Summary

Interface is the core mechanism to achieve polymorphism in Golang. Interface query is a method to determine whether an object implements an interface and how to use the object when the program is running. . In Golang, you can use type assertions and type judgments to perform interface queries and complete polymorphic operations on objects.

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