Let's talk about methods and interfaces in golang

Methods and interfaces in Go language are very important concepts. Mastering the use of these two knowledge points can improve the reusability and flexibility of Go language programs.

Method

In Go language, a method is a function associated with a specific type. It can be thought of as a function with a special receiver parameter type.

When declaring a method, the receiver parameters precede the method name. The receiver can be a value type or a pointer type. A value type receiver is equivalent to making a copy of the value, and a pointer type receiver passes the address of the value. This means that it is more efficient to use pointer type receivers because they avoid value copying in method calls.

The following is a sample program that demonstrates how to declare and use methods:

package main

import "fmt"

type Rectangle struct {
    width, height float64
}

func (r Rectangle) area() float64 {
    return r.width * r.height
}

func main() {
    r := Rectangle{3, 4}
    fmt.Println("Area: ", r.area())
}

In the above sample program, we define a structure type named Rectangle. This type has two fields width and height. We also define a method called area whose receiver is of type Rectangle and returns its area.

In the main function, we created a Rectangle type variable named r and called its area method.

Interface

An interface is a type that describes the behavior of an object. It defines a set of methods but does not implement them. The implementation of its methods is left to the respective specific types.

In the Go language, an interface is a type that can be implemented by any other type. If a type implements all methods specified in the interface, then the type is the implementation type of the interface.

The following is a sample program that demonstrates how to declare and use an interface:

package main

import "fmt"

type shape interface {
    area() float64
    perimeter() float64
}

type Rectangle struct {
    width, height float64
}

type Circle struct {
    radius float64
}

func (r Rectangle) area() float64 {
    return r.width * r.height
}

func (r Rectangle) perimeter() float64 {
    return 2*r.width + 2*r.height
}

func (c Circle) area() float64 {
    return 3.14 * c.radius * c.radius
}

func (c Circle) perimeter() float64 {
    return 2 * 3.14 * c.radius
}

func printShape(s shape) {
    fmt.Println("Area: ", s.area())
    fmt.Println("Perimeter: ", s.perimeter())
}

func main() {
    r := Rectangle{3, 4}
    c := Circle{5}

    printShape(r)
    printShape(c)
}

In the above sample program, we define an interface named shape. This interface defines two methods area and perimeter. We also defined two structural types, Rectangle and Circle, and implemented the methods defined by the shape interface on these types. Finally, we define a function called printShape that takes a parameter that implements the shape interface and prints the area and perimeter of that type.

In the main function, we create a Rectangle type variable named r and a Circle type variable named c and pass them to the printShape function. Since both Rectangle and Circle types implement the shape interface, they can be passed to the printShape function for processing.

Conclusion

In the Go language, methods and interfaces are very important concepts. They can help us better organize and reuse code, and improve the scalability and flexibility of the program. At the same time, they can also make our code easier to maintain and understand.

The above is the detailed content of Let's talk about methods and interfaces in golang. For more information, please follow other related articles on the PHP Chinese website!