How to implement interface in golang

In recent years, Golang (Go language) has become more and more popular among developers and has become the development language of choice for many Internet companies. Golang provides a simple and effective programming language mechanism and supports the concept of interface. In Golang, interface is a very important concept, and it is also a part that developers need to master.

This article will describe Golang's "interface" from the following aspects, including knowledge points such as defining and implementing interfaces, interface nesting, interface combinations, and custom types to implement interfaces.

Definition of interface

It is very simple to define an interface, just use the interface keyword, for example:

type Animal interface {
    Eat()
    Sleep()
}

The above code defines one The interface of Animal has two methods: Eat() and Sleep().

Implementation of interface

The implementation of interface is equivalent to a class implementing all the methods in an interface. In Golang, a class only needs to implement all the methods declared in the interface to be considered an implementation of the interface. For example:

type Cat struct {
    Name string
}

func (c Cat) Eat() {
    fmt.Printf("%s is eating.\n", c.Name)
}

func (c Cat) Sleep() {
    fmt.Printf("%s is sleeping.\n", c.Name)
}

In the above code, a class Cat is defined and all methods in the Animal interface are implemented. If you now create an instance of Cat and use it as Animal, it will work fine. For example:

var animal Animal
animal = Cat{"Tom"}
animal.Eat()
animal.Sleep()

In the above code, an instance of the Cat structure is assigned to Animal, and then by calling Eat() and Sleep() method to implement the interface.

Interface nesting

In Golang, interfaces can be nested in other interfaces, for example:

type Cat interface {
    Eat()
    Sleep()
}

type Animal interface {
    Cat
    Run()
}

In the above code, Animal interface is nested The Cat interface is set. This means that the Animal interface now has Eat() and Sleep() methods, as well as a Run() method.

Interface combination

When we need to use multiple interfaces, we can achieve it through interface combination. For example:

type Bird interface {
    Fly()
    Swim()
}

type Animal interface {
    Eat()
    Sleep()
}

type Creature interface {
    Animal
    Bird
}

In the above code, three interfaces are defined: Bird, Animal and Creature. Among them, Creature combines the two interfaces Animal and Bird. Since the Creature interface inherits the two interfaces Animal and Bird, it also has all the methods of these two interfaces.

Customized types implement interfaces

In Golang, in addition to structures that can implement interfaces, custom types can also implement interfaces. For example:

type MyInt int

func (m MyInt) Eat() {
    fmt.Println("Eating", m)
}

func (m MyInt) Sleep() {
    fmt.Println("Sleeping", m)
}

In the above code, a MyInt type is defined and Eat() and ## in the Animal interface are implemented. #Sleep() method. If you now create an instance of MyInt and then use it as Animal, it will also work normally:

var animal Animal
animal = MyInt(10)
animal.Eat()
animal.Sleep()

So far, we have said Understand the definition, implementation, nesting, combination and custom types of interfaces in Golang. As an important programming concept, interface is also very important in Golang. Mastering the knowledge related to interfaces can help us better use the Golang programming language to develop applications.

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