Quelles méthodes existe-t-il pour réaliser le polymorphisme en Golang ?

Quelles sont les méthodes d'implémentation du polymorphisme dans Golang ?

Le polymorphisme est un concept important dans la programmation orientée objet. Cela signifie que la même méthode peut être appelée par différents objets, et selon l'objet, l'implémentation spécifique de la méthode sera différente. Dans Golang, bien qu'il n'y ait pas de mécanisme d'héritage comme dans d'autres langages orientés objet, le polymorphisme peut être obtenu grâce à la combinaison d'interfaces et de structures.

1. Utilisez des interfaces pour réaliser le polymorphisme

Dans Golang, une interface est un type abstrait qui peut définir un ensemble de méthodes sans spécifier une implémentation spécifique. Le polymorphisme peut être obtenu en définissant une interface et en laissant différentes structures implémenter les méthodes de l'interface. Voici un exemple simple :

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "汪汪汪"
}

type Cat struct{}

func (c Cat) Speak() string {
    return "喵喵喵"
}

func main() {
    animals := []Animal{Dog{}, Cat{}}
    for _, animal := range animals {
        fmt.Println(animal.Speak())
    }
}

Dans le code ci-dessus, une interface Animal est définie, incluant la méthode Speak. Ensuite, les structures Dog et Cat sont définies et la méthode Speak est implémentée pour elles respectivement. Dans la fonction principale, Dog et Cat sont stockés dans la tranche en tant qu'éléments de type Animal, et le polymorphisme est implémenté en appelant la méthode Speak dans une boucle. Le résultat imprime « wouf wouf wouf » et « miaou miaou miaou ».

2. Utilisez des champs de structure pour réaliser le polymorphisme

Une autre façon d'obtenir le polymorphisme consiste à utiliser les champs d'une structure. Dans Golang, vous pouvez utiliser le type interface{} vide pour enregistrer différents types de valeurs. Le polymorphisme peut être obtenu en attribuant différentes structures aux champs de type interface{} vide. Voici un exemple :

type Shape interface {
    Area() float64
}

type Circle struct {
    radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.radius * c.radius
}

type Rectangle struct {
    length float64
    width  float64
}

func (r Rectangle) Area() float64 {
    return r.length * r.width
}

func main() {
    shapes := []Shape{Circle{radius: 2}, Rectangle{length: 3, width: 4}}
    for _, shape := range shapes {
        fmt.Println(shape.Area())
    }
}

Dans le code ci-dessus, une interface Shape est définie, incluant la méthode Area. Ensuite, les structures Cercle et Rectangle sont définies et les méthodes Area sont respectivement implémentées pour elles. Dans la fonction principale, affectez les structures Cercle et Rectangle aux éléments de type Shape et stockez-les dans la tranche, et implémentez le polymorphisme en appelant la méthode Area dans une boucle. Les résultats impriment l'aire du cercle et l'aire du rectangle.

Résumé :

Bien qu'il n'y ait pas de mécanisme d'héritage dans Golang, le polymorphisme peut être obtenu grâce à la combinaison d'interfaces et de structures. L'appel polymorphe de méthodes peut être réalisé en définissant une interface et en laissant différentes structures implémenter les méthodes de l'interface, ou en utilisant des champs de type interface{} vide pour stocker différents types de valeurs. Cette implémentation polymorphe confère à Golang les caractéristiques de la programmation orientée objet, rendant le code plus flexible et évolutif.

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!