Comment créer et configurer des interfaces dans Golang (une brève analyse des méthodes)

Dans Golang, l'interface est un type qui décrit le comportement des objets. En définissant des interfaces, nous pouvons standardiser les fonctions et les méthodes d'interaction des objets pour faciliter l'interaction de différents types d'objets.

Dans Golang, l'ensemble de méthodes d'une interface est composé d'un ensemble de définitions de méthodes. Le type qui implémente l'interface doit implémenter toutes les méthodes de l'interface. Cependant, lors de l'implémentation d'une interface, nous n'avons pas besoin de déclarer explicitement pour implémenter une interface, ni d'hériter d'une classe ou d'implémenter une interface. Nous devons uniquement implémenter l'ensemble de méthodes de l'interface. L'interface est implémentée sous forme de répartition dynamique, qui présente une bonne flexibilité et évolutivité.

Alors, comment créer et paramétrer des interfaces dans Golang ? Ensuite, nous le présenterons sous les aspects suivants.

1. Définir l'interface

Tout d'abord, nous devons définir l'interface, définir le type d'interface en ajoutant le mot-clé type à l'interface et définir l'ensemble de méthodes de l'interface entre parenthèses, par exemple :

type MyInterface interface {
    Method1() string
    Method2() int
}

Le code ci-dessus définit une interface nommée Le type d'interface de MyInterface contient deux méthodes Method1 et Method2. Notez que les méthodes définies dans l'interface n'ont pas de corps d'implémentation spécifiques, uniquement le nom de la méthode et le type de valeur de retour.

2. Implémentez l'interface

Ensuite, nous devons implémenter l'interface en définissant un type de structure qui implémente l'ensemble de méthodes d'interface, par exemple :

type MyStruct struct{}

func (m MyStruct) Method1() string{
    return "Method1 is called."
}

func (m MyStruct) Method2() int{
    return 100
}

Le code ci-dessus définit un type de structure nommé MyStruct, qui implémente les deux méthodes de l'interface MyInterface, Method1 et Method2. Il convient de noter que la méthode qui implémente l'interface doit utiliser le nom de la méthode, la liste des paramètres et le type de valeur de retour qui sont exactement les mêmes que ceux définis dans l'interface afin d'être reconnue comme une implémentation de l'interface. Dans cet exemple, la méthode définie dans le type MyStruct implémente également l'ensemble de méthodes de MyInterface, c'est-à-dire que l'interface MyInterface est implémentée.

3. Utilisation des interfaces

L'utilisation des interfaces est l'opération la plus basique liée aux interfaces dans Golang En définissant une variable de type interface, nous pouvons attribuer cette variable à différents types qui implémentent l'interface, par exemple :

var i MyInterface
i = MyStruct{}

fmt.Println(i.Method1())
fmt.Println(i.Method2())

Au-dessus du. le code définit une variable i de type MyInterfce et lui affecte une variable de type MyStruct. Parce que le type MyStruct implémente l'interface MyInterface, je peux accéder à toutes les méthodes définies dans MyInterface. Le résultat de sortie est :

Method1 is called.
100

Il convient de noter que lorsque nous attribuons une variable de type MyStruct à une variable de type MyInterface i, c'est en fait le cas. Une copie de la valeur de type MyStruct est affectée à la variable i de type MyInterface, ce qui est similaire à l'implémentation de fonction virtuelle en C++. Par conséquent, soyez prudent lorsque vous utilisez des types de pointeur pour implémenter des interfaces, car lorsque l'objet pointé par une variable de type pointeur change, cela peut affecter la disponibilité de l'implémentation de l'interface.

4. Imbrication d'interfaces

Dans Golang, les interfaces prennent également en charge l'imbrication, c'est-à-dire l'imbrication d'autres types d'interfaces en tant qu'ensembles de méthodes dans l'interface. Par exemple :

type MyInterface1 interface {
    Method1() string
}

type MyInterface2 interface {
    MyInterface1
    Method2() int
}

type MyStruct struct{}

func (m MyStruct) Method1() string{
    return "Method1 is called."
}

func (m MyStruct) Method2() int{
    return 100
}

func main() {
    var i MyInterface2
    i = MyStruct{}

    fmt.Println(i.Method1())
    fmt.Println(i.Method2())
}

Le code ci-dessus définit une interface MyInterface2, qui définit une interface MyInterface1 imbriquée et implémente les méthodes des interfaces MyInterface1 et MyInterface2. Le type MyStruct implémente également ces deux interfaces, il peut donc être affecté aux méthodes i et call.

5. Interface vide

Dans Golang, si nous ne connaissons pas le type spécifique d'un objet, mais que nous voulons quand même l'opérer, nous pouvons toujours utiliser des interfaces pour le compléter. C'est le concept de l'interface vide. L'interface vide est un type spécial dans Golang. Son ensemble de méthodes est vide et peut représenter n'importe quel type d'objet. Par exemple :

var i interface{}
i = 1

fmt.Println(i)

Le code ci-dessus définit une variable i de type interface{}, puis lui attribue l'entier 1. Étant donné que le type interface{} peut représenter n'importe quel type d'objet, nous pouvons afficher la valeur de i et obtenir le résultat correct.

Ce qui précède sont les méthodes de base de création et de configuration d'interfaces dans Golang. La maîtrise de l'utilisation des interfaces peut rendre le code plus flexible et évolutif, et améliorer la lisibilité et la maintenabilité du programme.

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!