Starting from scratch: Creation and implementation of Golang interface

Start from scratch: Creation and implementation of Golang interface

In Golang, an interface is a type that defines behavior. An interface defines a set of methods without providing specific implementations of these methods. An interface is an abstract type through which polymorphism can be achieved, making the program more flexible and extensible. This article will introduce how to create an interface in Golang and implement the specific methods of the interface, and provide code examples to help readers better understand.

1. Create an interface

In Golang, use the keywords type and interface to define an interface. An interface can contain any number of methods, each method consists of a method name, a parameter list, and a return value list. The following is a simple interface definition example:

package main

import "fmt"

// 定义一个接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

In the above example, we define an interface named Shape, which contains two methods Area() and Perimeter() are used to calculate the area and perimeter of the shape respectively.

2. Implement the interface

To implement an interface, you only need to define the methods in the interface on the custom type. The following is an example of implementing the Shape interface:

package main

import "fmt"

// 定义一个矩形类型
type Rectangle struct {
    Width  float64
    Height float64
}

// 实现Shape接口的Area方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 实现Shape接口的Perimeter方法
func (r Rectangle) Perimeter() float64 {
    return 2*r.Width + 2*r.Height
}

func main() {
    r := Rectangle{Width: 5, Height: 3}
    fmt.Println("矩形的面积：", r.Area())
    fmt.Println("矩形的周长：", r.Perimeter())
}

In the above code, we define a Rectangle type and implement Shape##Area() and Perimeter() methods of the interface. In the main function, we create a Rectangle object r and call the interface method it implements.

3. Polymorphism

Interfaces can achieve polymorphism in Golang, that is, instances of different types can implement the same interface and call the same method. This makes the program more flexible and scalable. Here is an example of using polymorphism:

package main

import "fmt"

// 定义一个圆形类型
type Circle struct {
    Radius float64
}

// 实现Shape接口的Area方法
func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

// 实现Shape接口的Perimeter方法
func (c Circle) Perimeter() float64 {
    return 2 * 3.14 * c.Radius
}

func main() {
    r := Rectangle{Width: 5, Height: 3}
    c := Circle{Radius: 2}

    shapes := []Shape{r, c}

    for _, shape := range shapes {
        fmt.Println("面积：", shape.Area())
        fmt.Println("周长：", shape.Perimeter())
    }
}

In the above example, we define a

Circle type and implement the Shape interface #Area() and Perimeter() methods. In the main function, we create a Rectangle object r and a Circle object c, and add them Put it into a slice of type []Shape. Then by traversing the slices and calling the methods of the Shape interface, the effect of polymorphism is achieved. Through the above examples, readers can better understand how to create interfaces in Golang and the specific methods to implement interfaces. Interface is an important feature in Golang, which can help us write more modular, flexible and extensible code. Hope this article can be helpful to readers.

The above is the detailed content of Starting from scratch: Creation and implementation of Golang interface. For more information, please follow other related articles on the PHP Chinese website!