Comment le golang est-il polymorphe ?

golang implémente le polymorphisme via des types d'interface et des liaisons de méthodes. Introduction détaillée : 1. Créez deux types de structure, Circle et Rectangle, qui implémentent respectivement l'interface Shape ; 2. Les structures Circle et Rectangle implémentent respectivement la méthode Area() dans l'interface Shape, réalisant ainsi le polymorphisme.

Le système d'exploitation de ce tutoriel : système windows10, Go version 1.20.1, ordinateur DELL G3.

Le polymorphisme est un concept important dans la programmation orientée objet, qui permet à différents types d'objets de répondre différemment au même message. En Aller Dans le langage, bien qu'il n'y ait pas de concepts traditionnels de classes et d'héritage, le polymorphisme peut être obtenu via des types d'interface et des liaisons de méthodes. Ci-dessous, j'expliquerai en détail comment implémenter le polymorphisme dans Go.

Interfaces et polymorphisme

en Go Le polymorphisme est généralement implémenté à l'aide d'interfaces. Une interface est une abstraction de type qui définit le comportement d'un objet. Un objet peut implémenter une ou plusieurs interfaces et le type d'interface est utilisé pour représenter l'objet. Étant donné que les interfaces peuvent référencer des objets de différents types, le polymorphisme peut être obtenu grâce aux types d'interface.

Définition de l'interface

Voici un exemple simple de définition d'interface :

type Shape interface {
Area() float64
}
type Printable interface {
Print()
}

Dans l'exemple ci-dessus, nous avons défini deux interfaces Shape et Printable. L'interface Shape contient un Area() Méthode de calcul de l'aire d'une forme ; l'interface Printable contient une méthode Print() pour imprimer les informations sur les objets.

Implémentation polymorphe

Le polymorphisme d'une interface est obtenu grâce aux méthodes des types qui implémentent l'interface. Ce qui suit est un exemple simple pour illustrer comment implémenter le polymorphisme dans Go.

Tout d'abord, nous créons deux types de structure, Circle et Rectangle, qui implémentent respectivement l'interface Shape :

type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
type Rectangle struct {
Width, Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}

Dans l'exemple ci-dessus, les structures Circle et Rectangle implémentent respectivement la méthode Area() dans l'interface Shape. Cela signifie qu'ils peuvent tous être traités comme des formes. Les types sont utilisés pour réaliser le polymorphisme.

Ensuite, nous pouvons écrire une fonction qui reçoit un paramètre de type Shape et calcule son aire :

func calculateArea(s Shape) {
fmt.Println("Area:", s.Area())
}

Maintenant, nous pouvons utiliser la fonction calculateArea pour calculer les aires de différents types de formes, quel que soit leur type. . Par exemple :

func main() {
c := Circle{Radius: 5}
r := Rectangle{Width: 3, Height: 4}
calculateArea(c) // 输出：Area: 78.53981633974483
calculateArea(r) // 输出：Area: 12
}

Dans la fonction principale, nous créons un cercle c et un rectangle r, puis appelons respectivement la fonction calculateArea pour calculer leurs aires. même si Le type de paramètre de la fonction calculateArea est le type d'interface Shape, mais elle peut toujours calculer correctement l'aire de diverses formes, ce qui est l'incarnation du polymorphisme.

Assertion de type et jugement de type

Lors de l'utilisation du polymorphisme d'interface, il est parfois nécessaire d'effectuer un traitement différent en fonction du type spécifique dans le programme. À ce stade, les assertions de type et les jugements de type peuvent être utilisés pour déterminer le type spécifique de la valeur d'interface et effectuer les opérations correspondantes.

Par exemple, vous pouvez utiliser le jugement de type pour déterminer le type spécifique de la valeur de l'interface :

func printInfo(p Printable) {
if shape, ok := p.(Shape); ok {
fmt.Println("This object is a shape.")
}
}

Dans l'exemple ci-dessus, nous utilisons le jugement de type pour déterminer si l'interface imprimable entrante implémente également l'interface Shape.

Les assertions de type peuvent être utilisées pour convertir les valeurs d'interface en types spécifiques :

func printArea(p Printable) {
if shape, ok := p.(Shape); ok {
fmt.Println("Area:", shape.Area())
}
}

Dans le code ci-dessus, nous affirmons la valeur de l'interface imprimable comme type de forme et appelons sa méthode Area() pour imprimer la zone.

Résumé

en Go Bien qu'il n'y ait pas de concepts traditionnels de classes et d'héritage dans le langage, le polymorphisme peut toujours être réalisé grâce à des interfaces et des méthodes. Grâce au polymorphisme d'interface, le code peut être rendu plus flexible et extensible, rendant le programme plus polyvalent et plus concis lorsqu'il s'agit de différents types d'objets. Dans le même temps, l’utilisation d’assertions de type et de jugements de type peut rendre le code polymorphe plus ciblé et mieux répondre aux besoins personnalisés des différents types d’objets.

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!