utilisation de l'interface golang

Le langage Go est un langage typé statiquement avec un système de types riche. L'interface est un type unique dans le langage Go et en constitue une partie importante. Dans cet article, nous présenterons en détail l'utilisation de l'interface Golang, y compris la définition, la mise en œuvre, l'utilisation, etc.

1. Définir l'interface

Une interface est un ensemble de méthodes qui peuvent être implémentées entre différents types. Utilisé pour décrire un comportement abstrait. En langage Go, vous pouvez utiliser les mots-clés type et interface pour définir des interfaces.

Lorsque vous utilisez le mot-clé type pour définir une interface, le format de syntaxe est le suivant :

type interface_name interface {
    method_name1 [return_type]
    method_name2 [return_type]
    …
    method_namen [return_type]
}

Dans la définition ci-dessus, interface_name est le nom de l'interface, method_namen est le nom de la méthode de l'interface, return_type est le type de valeur de retour de la méthode, s'il n'y a pas de valeur de retour, vous n'avez pas besoin de remplir cette section.

Ce qui suit est un exemple qui définit une interface nommée Shape, qui comprend une méthode nommée Area :

type Shape interface {
    Area() float64
}

Nous pouvons également définir plusieurs méthodes dans l'interface, telles que :

type Shape interface {
    Area() float64
    Perimeter() float64
}

2 Implémenter l'interface

In the Go. langage, l'implémentation de l'interface est implicite. Tant qu'un type possède toutes les méthodes définies dans l'interface, alors ce type implémente automatiquement l'interface. Cette approche est différente de l'implémentation explicite dans d'autres langages et est propre au langage Go.

Ce qui suit est un exemple d'implémentation de l'interface Shape, définissant deux types : Rectangle et Cercle. Le code est le suivant :

package main

import (
    "fmt"
    "math"
)

type Shape interface {
    Area() float64
}

type Rectangle struct {
    width, height float64
}

type Circle struct {
    radius float64
}

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

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

func main() {
    var s Shape
    r := Rectangle{width: 5, height: 3}
    c := Circle{radius: 2.5}

    s = r
    fmt.Println("Rectangle area:", s.Area())

    s = c
    fmt.Println("Circle area:", s.Area())
}

Dans le code ci-dessus, les types Rectangle et Circle implémentent respectivement la méthode Area dans l'interface Shape. Dans la fonction principale, nous créons une variable s de type Shape et l'attribuons respectivement à une instance de type Rectangle et Circle. Nous pouvons calculer l'aire de ces deux types en appelant la méthode s.Area(). Dans le langage Go, cette façon d'utiliser les interfaces est très flexible et peut facilement implémenter des modèles de programmation tels que le polymorphisme et l'injection de dépendances.

3. Interface vide

Dans le langage Go, tous les types implémentent une interface appelée interface vide, qui est définie comme suit :

type interface{}

L'interface vide n'a aucune méthode, elle peut donc être utilisée pour représenter n'importe quel type, similaire au type Object dans d’autres langages. En utilisant l'interface vide, une programmation très flexible peut être réalisée, comme le stockage de tout type de valeur dans une tranche.

Ce qui suit est un exemple d'utilisation de l'interface vide, définissant une fonction PrintAll qui peut imprimer des éléments dans n'importe quel type de tranche :

package main

import (
    "fmt"
)

func PrintAll(slice []interface{}) {
    for _, value := range slice {
        fmt.Println(value)
    }
}

func main() {
    var slice []interface{}
    slice = append(slice, 42, "hello", true)

    PrintAll(slice)
}

Dans le code ci-dessus, nous définissons une fonction nommée PrintAll, qui accepte une tranche de paramètre de type []interface{}. Cette fonction parcourt les éléments de la tranche et les imprime. Dans la fonction principale, nous créons une tranche, y ajoutons des éléments de type int, string et bool et la transmettons à la fonction PrintAll. En utilisant l'interface vide, nous pouvons implémenter tout type de passage et d'appel d'élément.

4. Résumé

Dans cet article, nous avons présenté la définition, la mise en œuvre et l'utilisation des interfaces dans le langage Go. En tant qu'une des fonctionnalités importantes du langage Go, les interfaces peuvent atteindre la flexibilité et l'évolutivité du code. Lorsque vous utilisez des interfaces, vous devez faire attention aux détails tels que leur implémentation et leur correspondance de type. Dans le même temps, nous avons également introduit l'utilisation d'interfaces vides et expliqué leur importance et leur rôle dans la programmation en langage Go.

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!