Exploration du polymorphisme dans le langage Go

Dans la programmation orientée objet, le polymorphisme permet aux objets de présenter différents comportements en fonction de leur classe. Mais dans Go, la notion de polymorphisme n'est pas mise en œuvre au sens traditionnel. Examinons les raisons derrière cela et explorons comment obtenir des fonctionnalités similaires dans Go.

Pourquoi Go manque de polymorphisme traditionnel

Go n'est pas un langage orienté objet traditionnel. Il adopte une approche différente en utilisant :

• Composition : objets composés d'autres objets ou interfaces.
• Interfaces : contrats qui définissent méthodes et comportements pour un type spécifique.

Contrairement aux langages orientés objet, Go ne prend pas en charge le remplacement de méthode ou les méthodes virtuelles. Cela permet à Go de maintenir un niveau plus élevé de sécurité de type.

Implémentation du polymorphisme à l'aide de la composition et des interfaces

Pour obtenir un comportement de type polymorphisme dans Go, nous pouvons utiliser les techniques suivantes :

1. Créer une interface commune : définissez une interface qui représente les comportements ou méthodes courants que vous souhaitez que vos types dérivés Implement.
2. Implémenter l'interface : implémentez les méthodes de l'interface dans vos types dérivés, chacun fournissant sa propre implémentation unique.
3. Utiliser la composition : Composer vos types dérivés en utilisant l'interface commune comme champ. Cela vous permet de traiter tous les types dérivés comme des instances de l'interface commune.

Exemple :

package main

import "fmt"

// Common interface
type Foo interface {
    printFoo()
}

// Derived type with unique implementation
type FooImpl struct{}

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

// Derived type composed using the common interface
type Bar struct {
    FooImpl
}

// Function returning the common interface
func getFoo() Foo {
    return Bar{}
}

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

Dans cet exemple, Foo est l'interface commune, FooImpl est le type dérivé avec sa propre implémentation et Bar est un type dérivé composé à l'aide de FooImpl. La fonction getFoo() renvoie une instance de l'interface Foo, nous permettant de traiter différents types dérivés comme un seul type d'interface.

Cette approche fournit une forme de polymorphisme dans Go en nous permettant de gérer différents types dérivés comme instances. d'une interface commune.