Comment hériter à Golang

Dans le langage Go, il n'y a pas de « classe » telle que définie dans les langages orientés objet traditionnels, il n'y a donc pas de soi-disant « héritage ». Cependant, le langage Go fournit une méthode permettant d'obtenir un héritage similaire via la composition, appelée Embedding.

L'intégration nous permet d'incorporer un type dans un autre type, afin que le type intégré puisse accéder directement aux propriétés et méthodes du type dans lequel il est intégré sans avoir à y accéder via une interface ou d'autres moyens. Ce processus est similaire au « héritage » traditionnel, mais plus flexible.

Ci-dessous, nous utiliserons plusieurs exemples pour montrer comment utiliser l'intégration pour obtenir une fonctionnalité de type héritage.

1. Exemple de base

Nous définissons d'abord quelques structures de base, chiens, chats et personnes :

type Dog struct {
    name string
}

func (d Dog) Bark() {
    fmt.Println(d.name, ": 汪汪汪！")
}

type Cat struct {
    name string
}

func (c Cat) Mew() {
    fmt.Println(c.name, ": 喵喵喵！")
}

type Person struct {
    name string
}

func (p Person) Speak() {
    fmt.Println(p.name, ": 你好！")
}

Maintenant, nous voulons créer un type d'animal, qui peut "hériter" des chiens et des chats, et qui possède également ses propres propriétés et méthodes, telles que la couleur et la vitesse de course. On peut le définir ainsi :

type Animal struct {
    Dog
    Cat
    color       string
    runSpeed    int
}

func (a Animal) Run() {
    fmt.Println(a.color, "的动物以", a.runSpeed, "km/h的速度奔跑！")
}

Dans cette définition, le type Animal embarque les types Chien et Chat. Cela signifie que les objets instanciés de type Animal peuvent accéder directement aux propriétés et méthodes de types Chien et Chat. Nous pouvons également définir nos propres propriétés et méthodes pour le type Animal, telles que color et runSpeed, pour représenter la couleur et la vitesse de course de l'animal, et définir une méthode Run pour décrire l'action de course de l'animal.

Créons maintenant un objet Animal et voyons comment il fonctionne :

func main() {
    d := Dog{name: "小黑"}
    c := Cat{name: "小白"}
    a := Animal{d, c, "黑白相间", 50}
    a.Bark()    // 小黑 : 汪汪汪！
    a.Mew()     // 小白 : 喵喵喵！
    a.Run()     // 黑白相间 的动物以 50 km/h的速度奔跑！
}

Nous pouvons voir qu'en intégrant les types Dog et Cat, l'objet Animal peut appeler directement les méthodes Bark et Mew sans utiliser d'interfaces ou d'autres moyens. Cette approche nous permet d'obtenir des fonctionnalités similaires sans utiliser « l'héritage » au sens traditionnel.

2. Incorporation de types personnalisés

Nous pouvons intégrer un type personnalisé dans un autre type personnalisé pour obtenir un effet similaire à l'héritage. Maintenant, définissons un type Personne et un type Étudiant, et intégrons le type Personne dans le type Étudiant :

type Person struct {
    name string
    age  int
    sex  string
}

type Student struct {
    Person
    class string
    score float64
}

Dans cette définition, le type Étudiant intègre le type Personne. Lors de l'instanciation d'un objet de type Student, vous pouvez utiliser les propriétés et méthodes de Person. Par exemple, nous pouvons instancier un objet étudiant et définir son nom, son âge, son sexe, sa classe et ses notes :

func main() {
    s := Student{
        Person: Person{
            name: "小明",
            age:  18,
            sex:  "男",
        },
        class: "高三一班",
        score: 92.5,
    }
    fmt.Println("姓名：", s.name)
    fmt.Println("年龄：", s.age)
    fmt.Println("性别：", s.sex)
    fmt.Println("班级：", s.class)
    fmt.Println("成绩：", s.score)
}

Lorsque nous exécutons ce programme, nous pouvons voir le résultat comme suit :

姓名： 小明
年龄： 18
性别： 男
班级： 高三一班
成绩： 92.5

Nous pouvons voir que l'objet Student peut Accédez directement aux propriétés et méthodes des objets de type Personne, y compris les attributs tels que le nom, l'âge et le sexe.

3. Intégration imbriquée

Il est également possible d'imbriquer plusieurs types dans un seul type. Nous pouvons intégrer le type Animal dans un autre type pour obtenir plus de fonctions. Par exemple, définissons maintenant un type Zoo :

type Zoo struct {
    Animal
    name    string
    address string
}

func (z Zoo) ShowInfo() {
    fmt.Println("这是", z.name, ", 地址是", z.address)
    z.Run()
}

Dans la définition de ce type, nous intégrons le type Animal dans le type Zoo. De cette manière, le type Zoo peut accéder directement aux propriétés et méthodes du type Animal, y compris la méthode Run. Nous définissons une autre méthode ShowInfo pour afficher le nom et l'adresse du zoo, et appelons la méthode Run de type Animal pour afficher les animaux en train de courir.

Maintenant, nous créons un objet Zoo et testons ses méthodes :

func main() {
    d := Dog{name: "小黑"}
    c := Cat{name: "小白"}
    a := Animal{d, c, "黑白相间", 50}
    z := Zoo{a, "北京动物园", "北京市海淀区清华科技园路"}
    z.ShowInfo()
}

Lorsque nous exécutons ce programme, nous pouvons voir le résultat comme suit :

这是 北京动物园 , 地址是 北京市海淀区清华科技园路
黑白相间 的动物以 50 km/h的速度奔跑！

Nous pouvons voir qu'en imbriquant le type Animal dans le type Zoo, nous pouvons créez un type avec plus de fonctions, qui peut afficher les informations du zoo et les actions en cours des animaux.

Résumé

Bien qu'il n'y ait pas de concepts de classes et d'héritage définis par les langages orientés objet traditionnels dans le langage Go, le concept d'intégration nous permet d'obtenir des fonctions similaires sans utiliser les méthodes d'héritage traditionnelles, ce qui le rend plus flexible et plus pratique. À travers les exemples ci-dessus, nous pouvons voir que l'intégration facilite la création d'un type contenant des sous-types et l'appel pratique de leurs méthodes et propriétés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!