Comment Go implémente-t-il le polymorphisme sans l’appliquer ?

Polymorphisme en Go

Dans la programmation orientée objet, le polymorphisme permet à une seule interface de faire référence à des objets de plusieurs types. Go n'applique pas strictement ce concept, mais il propose des moyens alternatifs pour obtenir un comportement similaire.

Considérez l'extrait de code suivant :

type Foo struct {
   ...
}

type Bar struct {
   Foo
   ...
}

func getFoo() Foo {
   return Bar{...}
}

Comme vous l'avez remarqué, dans Go, ce code génère un erreur indiquant que getFoo() doit renvoyer une instance de Foo. Pour obtenir un comportement polymorphe, vous pouvez utiliser des interfaces et une composition dans Go :

package main

import "fmt"

type Foo interface {
   printFoo()
}

type FooImpl struct {

}

type Bar struct {
   FooImpl
}

type Bar2 struct {
   FooImpl
}

func (f FooImpl)printFoo(){
    fmt.Println("Print Foo Impl")
}

func getFoo() Foo {
   return Bar{}
}

func main() {
    fmt.Println("Hello, playground")
    b := getFoo()
    b.printFoo()
}

Dans cet exemple mis à jour :

• Nous définissons une interface appelée Foo qui déclare une fonction printFoo.
• FooImpl implémente l'interface Foo.
• Bar et Bar2 sont des structures qui intègrent le type FooImpl.
• La fonction getFoo() renvoie une valeur qui implémente l'interface Foo, permettant pour renvoyer une instance Bar ou Bar2.
• Lors de l'appel de printFoo sur la valeur renvoyée par getFoo(), Go distribue dynamiquement la méthode en fonction du type sous-jacent.

Cette technique fournit un moyen d'obtenir le polymorphisme dans Go en utilisant des interfaces et une composition, permettant d'utiliser une seule interface pour différents types de béton.

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!