Golang implémente le polymorphisme

Golang est un langage de programmation qui prend en charge la programmation orientée objet. Bien qu'il n'ait pas de concepts tels que les classes, l'héritage et le polymorphisme dans les langages de programmation orientés objet traditionnels, il existe de nombreuses méthodes dans Golang pour obtenir le polymorphisme. Cet article expliquera comment implémenter le polymorphisme dans Golang.

1. Interface

Dans Golang, l'interface est un moyen d'atteindre le polymorphisme. Une interface est un ensemble de méthodes. Tant qu'un type implémente toutes les méthodes de l'interface, il est considéré comme implémentant l'interface. Cette méthode est plus flexible et moins couplée au code que la méthode d'héritage traditionnelle.

Ce qui suit est un exemple d'implémentation d'une interface :

type Animal interface {
    Move()
    Speak()
}

type Dog struct {
    Name string
}

func (d Dog) Move() {
    fmt.Printf("%s is moving\n", d.Name)
}

func (d Dog) Speak() {
    fmt.Printf("%s is speaking\n", d.Name)
}

func main() {
    var a Animal
    a = Dog{Name: "Tom"}
    a.Move()
    a.Speak()
}

Dans le code ci-dessus, une interface Animal est définie, qui contient deux méthodes Move et Speak. Ensuite, une structure Dog est définie, qui implémente deux méthodes dans l'interface Animal. Dans la fonction principale, une variable a de type Animal est définie et affectée à une instance de type Chien. Appelez ensuite les méthodes Move et Speak de a. Étant donné que Dog implémente l'interface Animal, il peut être appelé directement.

Il convient de noter ici que l'interface dans Golang est implémentée implicitement, c'est-à-dire que tant que le type implémente toutes les méthodes de l'interface, l'interface est automatiquement implémentée sans déclaration explicite.

2. L'imbrication de structures

L'imbrication de structures est aussi un moyen d'atteindre le polymorphisme. En imbriquant un type dans un autre type, vous pouvez interfacer les méthodes du type imbriqué et définir une méthode d'interface commune dans le type externe, réalisant ainsi le polymorphisme.

Ce qui suit est un exemple d'imbrication de structure :

type Animal struct {
    Name string
}

func (a Animal) Move() {
    fmt.Printf("%s is moving\n", a.Name)
}

type Dog struct {
    Animal
}

func (d Dog) Speak() {
    fmt.Printf("%s is speaking\n", d.Name)
}

type Cat struct {
    Animal
}

func (c Cat) Speak() {
    fmt.Printf("%s is speaking\n", c.Name)
}

type Moveable interface {
    Move()
}

type Speakable interface {
    Speak()
}

func main() {
    var m Moveable
    var s Speakable
    m = Dog{Animal{Name: "Tom"}}
    s = Cat{Animal{Name: "Kitty"}}
    m.Move()
    s.Speak()
}

Dans le code ci-dessus, une structure Animal est définie, puis les structures Chien et Chat sont définies respectivement. tous imbriqués dans la structure Animal et implémentent leurs propres méthodes. Ensuite, une interface Moveable et une interface Speakable sont définies, et les variables m et s contenant ces deux interfaces sont déclarées dans la fonction principale et affectées respectivement aux instances de types Dog et Cat. Appelez ensuite respectivement la méthode Move de m et la méthode Speak de s pour afficher les informations correspondantes.

Grâce à l'imbrication de structures, nous pouvons implémenter un type d'interface commun pour réaliser le polymorphisme. Il convient de noter que les structures imbriquées ne peuvent pas avoir de méthodes ou de champs portant le même nom, sinon des conflits se produiraient.

3. Instruction Switch

En plus de l'imbrication d'interface et de structure, l'instruction switch peut également être utilisée pour réaliser le polymorphisme dans Golang.

Ce qui suit est un exemple d'utilisation de l'instruction switch pour obtenir un polymorphisme :

type Animal struct {
    Name string
    Type string
}

func (a Animal) Move() {
    fmt.Printf("%s is moving\n", a.Name)
}

func (a Animal) Speak() {
    switch a.Type {
    case "dog":
        fmt.Printf("%s is barking\n", a.Name)
    case "cat":
        fmt.Printf("%s is meowing\n", a.Name)
    }
}

func main() {
    d := Animal{Name: "Tom", Type: "dog"}
    c := Animal{Name: "Kitty", Type: "cat"}
    d.Move()
    d.Speak()
    c.Move()
    c.Speak()
}

Dans le code ci-dessus, une structure Animal est définie et dans la structure les méthodes Move et Speak . L'instruction switch est utilisée dans la méthode Speak pour générer différentes informations en fonction de l'attribut Type d'Animal. Dans la fonction principale, une instance Animal de type chien et une instance Animal de type chat sont définies, et leurs méthodes Move et Speak sont appelées respectivement. Étant donné que les informations générées par la méthode Speak sont différentes selon l'attribut Type, le polymorphisme est implémenté.

Il convient de noter que lors de l'utilisation de l'instruction switch pour implémenter le polymorphisme, elle doit être jugée en fonction du type et de la sortie en conséquence. S'il existe plusieurs types, la complexité du code peut être plus élevée.

Résumé :

Cet article présente trois façons d'implémenter le polymorphisme dans Golang : les interfaces, l'imbrication de structures et les instructions switch. Différentes méthodes ont leurs propres avantages et scénarios applicables. Les développeurs peuvent choisir la méthode appropriée pour implémenter le polymorphisme en fonction de besoins spécifiques.

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!