What are the exposed methods of golang interface?

Golang is a programming language for quickly developing high-performance applications. Its powerful functions and interface mechanisms make it one of the preferred languages ​​in the field of cloud computing and distributed systems. In Golang, interface is a very important language feature that can help us better adapt to complex business logic. This article discusses how to expose methods using interfaces.

In Golang, an interface refers to a set of methods, and the declaration of these methods is fixed. Interfaces define the behavioral characteristics that some types should have. Different types can implement the same interface, so that they can be regarded as the same type, making it easier to operate on them.

The interface is defined using the "interface" keyword, and the interface can be implemented by implementing the methods in the interface. Each method in an interface has no body, which means that they need to be defined in the type that implements the interface.

Next let’s look at a simple example. Suppose we have an Animal structure and an interface CanFly. We hope to implement the interface CanFly and make the animal flyable by implementing the Fly() method.

// 动物结构体
type Animal struct {
    Name string
}

// 飞行接口
type CanFly interface {
    Fly()
}

// 实现CanFly接口的方法
func (a Animal) Fly() {
    fmt.Println(a.Name + " is flying")
}

func main() {
    bird := Animal{Name: "Bird"}
    bird.Fly() // output: Bird is flying
}

In the above example, we defined a structure named Animal and added a string type Name field to it. Then, we define an interface called CanFly, which has only one method called Fly method. Next, we implemented the Fly method in the Animal type. Finally, in the main function, we create an Animal instance and call its Fly method.

However, in some cases, we need to expose the methods in the interface as external APIs for clients to call. At this point, we need to use the type assertion mechanism to convert the type that implements the interface into the interface, and then we can call its methods.

Let's look at a more complex example. We define another Dog structure so that it also implements the CanFly interface.

// 狗结构体
type Dog struct {
    Name string
}

// 实现CanFly接口的方法
func (d Dog) Fly() {
    fmt.Println(d.Name + " is flying")
}

func main() {
    bird := Animal{Name: "Bird"}
    dog := Dog{Name: "Dog"}

    // 定义接口列表
    items := []CanFly{bird, dog}

    // 遍历接口列表，调用Fly方法
    for i := range items {
        if f, ok := items[i].(CanFly); ok {
            f.Fly()
        }
    }
}

In the above example, we first defined a structure named Dog and implemented the Fly method in the CanFly interface. Then, in the main function, we create an Animal instance and a Dog instance and add them to a list of interfaces of type CanFly. Finally, we iterate through this list and use the type assertion mechanism to convert them into CanFly interfaces and call their Fly methods.

It should be noted that when using the type assertion mechanism, we need to check the second value returned (ok of bool type). This value indicates whether the type conversion to the interface type was successful. If the conversion is successful, then we can safely call methods in the interface.

In short, in the Go language, interfaces are very useful features that can help us build efficient, flexible and reusable code. By exposing methods through interfaces, we can focus more on design and improve the maintainability and reusability of code.

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