golang inheritance method

The Go language (Golang) does not provide the inheritance mechanism in traditional object-oriented languages, but you can use the structure (struct) type and embedded fields (embedded fields) to achieve effects similar to inheritance. In this article, we will introduce how to implement inheritance and method overriding in Golang.

1. Structure embedding

Structure embedding is a way to implement inheritance in Golang. In structure embedding, a structure embeds another structure into its own definition, so that the fields and methods in the parent structure will become part of the child structure, and the child structure can directly access these fields and methods .

The following code demonstrates how to use structure embedding to implement inheritance:

package main

import "fmt"

// 父结构体
type Animal struct {
    name string
}

// 父结构体的方法
func (a *Animal) Move() {
    fmt.Printf("%s is moving.
", a.name)
}

// 子结构体
type Dog struct {
    Animal // 继承自Animal结构体
}

// 子结构体的方法
func (d *Dog) Bark() {
    fmt.Printf("%s is barking.
", d.name)
}

func main() {
    // 创建一个Dog结构体
    dog := &Dog{Animal{"旺财"}}
    // 调用父结构体的方法
    dog.Move()
    // 调用子结构体的方法
    dog.Bark()
}

In the above code, we define an Animal parent structure and a Dog substructure. In the substructure, we use the Animal structure to embed the Animal structure, so that the substructure contains all the fields and methods of the Animal structure in its definition. Therefore, in the child structure we can directly call the Move method in the parent structure.

2. Method overriding

After implementing inheritance in Golang, we can use method overriding to override methods in the parent structure. Method overriding refers to redefining a method in the substructure with the same name as the parent structure, so that the method of the substructure will be called first when called.

The following code demonstrates how to use method rewriting to implement inheritance:

package main

import "fmt"

type Animal struct {
    name string
}

func (a *Animal) Move() {
    fmt.Printf("%s is moving.
", a.name)
}

// 子结构体
type Dog struct {
    Animal
}

// 子结构体中重写Move方法
func (d *Dog) Move() {
    fmt.Printf("%s is running.
", d.name)
}

func main() {
    dog := &Dog{Animal{"旺财"}}
    // 调用重写后的Move方法
    dog.Move()
}

In the above code, we rewrite the Move method in the parent structure Animal, and the child structure Dog The Move method in overrides the Move method in the parent structure. Therefore, when dog.Move() is called, the Move method in the substructure will be called, and the output result is "Wangcai is running.".

It should be noted that conflicts should be noted when using structure embedding and method overriding. If fields or methods with the same name are defined in both the parent structure and the child structure, conflicts will occur during access. The way to resolve this conflict is to indicate the specific structure when calling, such as animal.Move() and dog.Animal.Move().

Summary:

In this article, we introduced how to achieve inheritance-like effects through structure embedding and method rewriting in Golang. Struct embedding allows you to inherit the fields and methods of a parent structure by embedding the parent structure into the definition of a child structure. Method overriding can override methods in the parent structure by overriding the methods of the parent structure in the child structure. Although there is no explicit inheritance mechanism in Golang, with the help of structure embedding and method rewriting, we can achieve inheritance-like effects.

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