The golang interface cannot be understood

Golang (also known as Go) is a high-performance, concurrent programming language that is simple, powerful, and safe. Compared with other languages, Golang has high advantages in handling I/O-intensive tasks, high-concurrency tasks, and network programming. Among them, interface is a very important feature in Golang. For beginners, understanding interface may be one of the challenging things. In this article, we will explore the basics and important concepts of Golang interfaces.

First, let us review the definition of interface. In Golang, an interface is a type that is not bound to a specific data type like other languages, but abstracts some common set of methods. These methods can be used to describe a set of similar behaviors regardless of the specific data type. This makes the interface highly flexible and easy to expand and maintain.

Let’s look at a practical example. Suppose we have an interface representing a shape, which contains two methods for calculating area and perimeter:

type Shape interface {

Area() float64
Perimeter() float64

}

Now, we can Implement this interface for different graphics types. For example, the implementation code of a circle can be:

type Circle struct {

Radius float64

}

func (c Circle) Area() float64 {

return math.Pi * c.Radius * c.Radius

}

func (c Circle) Perimeter() float64 {

return 2 * math.Pi * c.Radius

}

Here we define a circle, which has a radius attribute Radius. The Area method returns the area of ​​a circle, while the Perimeter method returns the circumference of a circle. These two methods must be implemented on the Circle type respectively to meet the requirements of the Shape interface. Similarly, if we have an implementation of the rectangle type, we can also implement this interface. The code is as follows:

type Rectangle struct {

Width  float64
Height float64

}

func (r Rectangle) Area () float64 {

return r.Width * r.Height

}

func (r Rectangle) Perimeter() float64 {

return 2 * (r.Width + r.Height)

}

As you can see, this rectangle type also Two methods are implemented according to the requirements of the Shape interface. Now we can define a Slice containing different shapes, and then traverse this Slice to calculate their area and perimeter:

func TotalArea(shapes []Shape) float64 {

var area float64
for _, shape := range shapes {
    area += shape.Area()
}
return area

}

func TotalPerimeter(shapes []Shape) float64 {

var perimeter float64
for _, shape := range shapes {
    perimeter += shape.Perimeter()
}
return perimeter

}

In this way, we can calculate different graphic types without knowing their specific types. This is a very useful use case for interfaces.

However, for beginners, the interface may also add some difficulty. First, the interface itself has no actual data type, it just describes a set of methods. Therefore, we cannot directly use variables of interface types for assignment or comparison operations, and must convert them to specific types. For example, we define an interface type variable var s Shape, and we must convert it to a specific type before we can call its method:

c := Circle{Radius: 2}
var s Shape = c
// The following syntax converts s to Circle type and calls the Area method
area := s.(Circle).Area()

During conversion, if the actual type of s is not Circle type, Then a panic exception will be thrown. Therefore, we must ensure that the conversion of interface variable types is safe.

In addition, interface types in Golang do not support generics. This means that we cannot accept any type of data directly through the interface type. We need to clearly define the specific interface type according to the definition of the interface. This may be inconvenient for scenarios where generics are often used in other languages.

To summarize, the interface in Golang is an important part of its programming model. By defining a common set of methods, you can provide consistent interfaces for different types, thereby improving program flexibility and maintainability. However, beginners may encounter some challenges in understanding the concept of interfaces and using interface type variables, and it will take some time to master them.

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