Comment implémenter des interfaces en langage Go

Le langage Go (également appelé Golang) est un langage de programmation open source développé par Google. Il présente les caractéristiques d'efficacité, de fiabilité et de simplicité. Une fonctionnalité importante du langage Go est "l'interface". Une interface est une collection de signatures de méthodes et est un type abstrait. Cet article présentera comment implémenter des interfaces en langage Go.

1. Définition de l'interface

En langage Go, la définition de l'interface utilise le mot-clé "interface", et le format de syntaxe est le suivant :

type 接口名 interface{
    方法名1(参数列表1) 返回值列表1
    方法名2(参数列表2) 返回值列表2
    ……
}

Parmi eux, la dénomination du nom de l'interface et du nom de la méthode suit la convention de dénomination du langage Go. Les noms de méthodes sont nommés en casse chameau. La première lettre du nom de méthode est en majuscule pour indiquer qu'elle est visible par le monde extérieur. Dans une interface, le nom de la méthode, ainsi que la liste des paramètres et la liste des valeurs de retour, sont appelés « signature de méthode ».

2. Implémentation de l'interface

L'implémentation de l'interface fait référence au bloc de code de méthode qui implémente l'interface en fonction de la signature de méthode définie par l'interface. Une méthode qui implémente une interface nécessite une signature de méthode qui répond aux exigences de l'interface. Cette méthode est appelée « méthode d'interface ».

La mise en œuvre de l'interface nécessite l'utilisation du mécanisme de conversion de type unique du langage Go. Plus précisément, l'implémentation de l'interface doit convertir le type d'implémentation (le type qui implémente la méthode d'interface) en type d'interface (le type qui implémente l'interface) en implémentant la « méthode d'interface ». Dans la conversion de type, le type d'implémentation doit implémenter toutes les signatures de méthode définies par l'interface ; n'importe quelle interface peut implémenter l'interface tant que toutes les méthodes sont implémentées.

Par exemple, nous définissons une interface "animal" et deux structures "chien" et "chat", et implémentons les "méthodes d'interface" correspondant à ces deux structures. Le code est le suivant :

type Animal interface {
    Speak() string
}

type Dog struct {
}

func (d Dog) Speak() string {
    return "汪汪汪"
}

type Cat struct {
}

func (c Cat) Speak() string {
    return "喵喵喵"
}

func main() {
    var animal Animal //定义一个Animal类型变量
    animal = Dog{}     //将Dog类型的结构体转换为Animal类型的接口实现
    fmt.Println(animal.Speak())

    animal = Cat{}     //将Cat类型的结构体转换为Animal类型的接口实现
    fmt.Println(animal.Speak())
}

Dans le code ci-dessus, nous définissons une interface « Animal », qui contient la méthode d'interface « Parler » en même temps, nous définissons deux types, à savoir « Chien » et « Chat », et implémenter leurs méthodes d'interface « Parler » correspondantes. Dans la fonction principale, nous implémentons l'appel de la méthode "Speak" en convertissant les variables de type "Dog" et "Cat" en implémentation d'interface de type "Animal".

3. Implémentation de plusieurs interfaces

Dans le langage Go, une structure peut implémenter plusieurs interfaces, et une interface peut être implémentée par plusieurs structures en même temps. Dans ce cas, nous devons utiliser une combinaison pour implémenter plusieurs interfaces.

Par exemple, nous définissons une interface "animal" et une interface "pet", et nous implémentons respectivement les interfaces "animal" et "pet" dans la structure "chien". Le code est le suivant :

type Animal interface {
    Speak() string
}

type Pet interface {
    Name() string
}

type Dog struct {
    name string
}

func (d Dog) Speak() string {
    return "汪汪汪"
}

func (d Dog) Name() string {
    return d.name
}

func main() {
    var animal Animal //定义一个Animal类型变量
    animal = Dog{name: "小明"} //将Dog类型的结构体转换为Animal类型的接口实现
    fmt.Println(animal.Speak())

    var pet Pet       //定义一个Pet类型变量
    pet = Dog{name: "小花"}   //将Dog类型的结构体转换为Pet类型的接口实现
    fmt.Println(pet.Name())
}

Dans le code ci-dessus, nous avons défini une interface « animal » et une interface « pet », et implémenté les méthodes d'interface correspondant à la structure « chien ». Dans la fonction principale, nous convertissons respectivement la structure « dog » en implémentation d'interface « animal » et en implémentation d'interface « pet », réalisant ainsi l'appel des méthodes « Speak » et « Name ».

4. Résumé

L'interface en langage Go est une fonctionnalité importante, qui peut réaliser le polymorphisme et nous aider à réaliser l'idée de programmation orientée interface. En langage Go, la définition et la mise en œuvre des interfaces sont très simples, mais il faut maîtriser le mécanisme de conversion de type du langage Go. Cet article présente brièvement les interfaces et les implémentations d'interfaces en langage Go, et explique la situation de plusieurs interfaces à travers des exemples.

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!