Une plongée approfondie dans la mise en œuvre des interfaces Golang

Golang (également connu sous le nom de langage Go) est un langage de programmation moderne conçu et maintenu par Google. Golang est un langage statique qui améliore la maintenabilité et la robustesse du code grâce à un typage fort et une vérification de type stricte. L'une des fonctionnalités les plus intéressantes concerne les interfaces, et cet article se penchera sur la mise en œuvre des interfaces Golang.

Qu'est-ce que l'interface Golang ?

Comme d'autres langages de programmation orientés objet tels que C++ et Java, Golang prend également en charge les interfaces. Dans Go, une interface est une déclaration d'un ensemble de méthodes, et un type d'interface est un ensemble de types qui doivent implémenter ces méthodes. En termes simples, une interface est un type abstrait qui définit les signatures de méthodes mais pas les implémentations. Une interface peut contenir 0 ou plusieurs signatures de méthode et ne contient aucun champ.

L'interface peut être comparée à une carte. La carte stipule certaines règles d'utilisation, afin que la personne qui implémente l'interface de la carte sache qu'elle doit suivre ces règles de codage, ce qui rend le codage plus pratique et le code plus efficace. a été amélioré.

Implémentation des interfaces

Il est très simple d'implémenter des interfaces dans Golang. Un type n'a besoin que d'implémenter toutes les méthodes du type d'interface, et il peut être appelé le type d'implémentation de ce type d'interface. Le processus de définition et d'implémentation d'une interface est le suivant :

type interfaceName interface{
    method1(param1 type1, param2 type2, ...) (return1 type1, return2 type2, ...)
    method2(param1 type1, ...) (return1 type1, ...)
    ...
}

type myType struct {
    // myType 的一些域
}

func (t *myType) method1(param1 type1, param2 type2, ...) (return1 type1, return2 type2, ...) {
    // 方法体
}
func (t *myType) method2(param1 type1, ...) (return1 type1, ...) {
    // 方法体
}
// ...

Dans le code ci-dessus, nous définissons une interface interfaceName, qui contient plusieurs méthodes. Ensuite, nous avons défini une structure myType, qui possède certaines propriétés, puis nous avons implémenté les méthodes respectivement dans interfaceName. De cette façon, myType devient le type d’implémentation de interfaceName.

Il est à noter que l'implémentation de l'interface est non intrusive, c'est-à-dire qu'on n'a pas besoin de modifier les types définis, il suffit de définir les méthodes à implémenter.

La relation entre les types d'interface et les types d'implémentation

Un type d'interface peut établir plusieurs types d'implémentation. En d’autres termes, un type d’interface peut être implémenté par plusieurs types. Voici un exemple :

type Animal interface {
    Move() string
}

type Dog struct {}

func (d Dog) Move() string {
    return "I'm a dog, I can walk on 4 legs"
}

type Bird struct {}

func (b Bird) Move() string {
    return "I'm a bird, I can fly"
}

func main() {
    d := new(Dog)
    b := new(Bird)
    animal1 := Animal(d)
    animal2 := Animal(b)
    fmt.Println(animal1.Move())
    fmt.Println(animal2.Move())
}

Dans l'exemple ci-dessus, nous avons défini une interface Animal et deux types d'implémentations : Dog et Bird. Ensuite, nous avons créé des objets animal1 et animal2, leurs types sont tous deux Animal, mais les types réels vers lesquels ils pointent sont respectivement Dog et Bird. Enfin, dans la fonction principale, les méthodes Move() de animal1 et animal2 sont appelées respectivement, et leurs modes de mouvement sont générés en fonction du comportement réel du type.

Nous pouvons voir que la méthode Move() du type réel implémente la méthode Move() du type interface. Tant que le type implémente l'interface, il peut être appelé un type d'implémentation.

Interface vide

L'interface vide interface {} dans Golang est une interface spéciale qui n'a aucune méthode et peut représenter n'importe quel type, ce qui est équivalent à la classe Object en Java. Peut être utilisé pour définir des paramètres ou renvoyer des valeurs de tout type, tels que :

func foo(a interface{}) {
    switch a.(type){
    case string:
        fmt.Println("this is string type")
    case int:
        fmt.Println("this is int type")
    default:
        fmt.Println("unknown type")
    }
}

func main() {
    foo("hello")
    foo(42)
    foo(3.14159)
}

Dans l'exemple ci-dessus, nous avons défini une fonction foo dont le paramètre est une interface vide de type a. Nous utilisons une instruction switch pour déterminer le type réel de a et répondre en conséquence. Comme vous pouvez le constater, l'interface vide peut recevoir tout type de paramètres.

Résumé

La mise en œuvre de l'interface Golang est une chose très simple. Tant qu'un type implémente toutes les méthodes d'un type d'interface, il est appelé type d'implémentation de ce type d'interface. Un type d’interface peut avoir plusieurs types d’implémentation. L'interface vide est une interface spéciale qui n'a aucune méthode et peut représenter n'importe quel type. De plus, l’interface est non intrusive, ce qui améliore grandement la flexibilité et la lisibilité de l’écriture du code.

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!