How is golang polymorphic?

Golang implements polymorphism through interface types and method bindings. Detailed introduction: 1. Create two structure types, Circle and Rectangle, which implement the Shape interface respectively; 2. The Circle and Rectangle structures respectively implement the Area() method in the Shape interface, thereby achieving polymorphism.

The operating system for this tutorial: Windows 10 system, Go 1.20.1 version, DELL G3 computer.

Polymorphism is an important concept in object-oriented programming, which allows different types of objects to respond differently to the same message. In Go In the language, although there are no traditional concepts of classes and inheritance, polymorphism can be achieved through interface types and method bindings. Below I will explain in detail how to implement polymorphism in Go.

Interfaces and Polymorphism

In Go Polymorphism is usually implemented using interfaces. An interface is a type abstraction that defines the behavior of an object. An object can implement one or more interfaces, and the interface type is used to represent the object. Because interfaces can reference objects of different types, polymorphism can be achieved through interface types.

Interface definition

The following is a simple interface definition example:

type Shape interface {
Area() float64
}
type Printable interface {
Print()
}

In the above example, we define two interfaces Shape and Printable. The Shape interface contains an Area() Method for calculating the area of ​​a shape; the Printable interface contains a Print() method for printing object information.

Polymorphic implementation

The polymorphism of the interface is achieved by implementing the method of the interface type. The following is a simple example to illustrate how to implement polymorphism in Go.

First, we create two structure types, Circle and Rectangle, which implement the Shape interface respectively:

type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
type Rectangle struct {
Width, Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}

In the above example, the Circle and Rectangle structures respectively implement the Shape interface. Area() method. This means that they can all be treated as Shape Types are used to achieve polymorphism.

Next, we can write a function that receives a parameter of type Shape and calculates its area:

func calculateArea(s Shape) {
fmt.Println("Area:", s.Area())
}

Now, we can use the calculateArea function to calculate the area of ​​different types of shapes, and It doesn't matter what type of shape it is. For example:

func main() {
c := Circle{Radius: 5}
r := Rectangle{Width: 3, Height: 4}
calculateArea(c) // 输出：Area: 78.53981633974483
calculateArea(r) // 输出：Area: 12
}

In the main function, we create a circle c and a rectangle r, and then call the calculateArea function respectively to calculate their areas. even though The parameter type of the calculateArea function is the Shape interface type, but it can still correctly calculate the area of ​​various shapes, which is the embodiment of polymorphism.

Type assertion and type judgment

When using interface polymorphism, sometimes it is necessary to do different processing according to the specific type in the program. At this time, type assertions and type judgments can be used to determine the specific type of the interface value and perform corresponding operations.

For example, you can use type judgment to determine the specific type of the interface value:

func printInfo(p Printable) {
if shape, ok := p.(Shape); ok {
fmt.Println("This object is a shape.")
}
}

In the above example, we use type judgment to determine whether the incoming Printable interface also implements Shape interface.

Type assertions can be used to convert interface values ​​​​to specific types:

func printArea(p Printable) {
if shape, ok := p.(Shape); ok {
fmt.Println("Area:", shape.Area())
}
}

In the above code, we assert the Printable interface value as the Shape type and call its Area() Method to print area.

Summary

In Go Although there are no traditional concepts of classes and inheritance in the language, polymorphism can still be well achieved through interfaces and methods. With the help of interface polymorphism, the code can be made more flexible and extensible, making the program more versatile and concise when dealing with different types of objects. At the same time, using type assertions and type judgments can make polymorphic code more targeted and better handle the personalized needs of different types of objects.

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