implémentation par défaut de l'interface Golang

Afin de rendre le code plus flexible et évolutif, il est souvent nécessaire d'utiliser des interfaces pour le développement. Dans le langage Go, l'interface est une fonctionnalité de langage très puissante qui prend en charge plusieurs structures pour implémenter la même interface.

Cependant, dans le passé, le langage Go ne prenait pas en charge l'implémentation par défaut des interfaces, ce qui signifiait que lors de l'implémentation d'une interface, toutes les méthodes de l'interface devaient être implémentées. Lorsque vous devez hériter d'une interface, vous devez implémenter la même méthode encore et encore dans la sous-interface, ce qui entraîne un degré élevé de duplication de code et n'est pas propice à l'expansion et à la maintenance du code.

Afin de résoudre ce problème, à partir de la version 1.8 du langage Go, la prise en charge de l'implémentation par défaut de l'interface est fournie. Cette fonctionnalité nous permet de définir des implémentations par défaut des méthodes dans l'interface, de sorte que seules les méthodes nécessaires doivent être implémentées lors de l'implémentation de l'interface.

La syntaxe de l'implémentation par défaut de l'interface

La syntaxe de l'implémentation par défaut de l'interface est très simple Il vous suffit d'ajouter le mot-clé default avant l'implémentation de la méthode. Par exemple :

type Reader interface {

Read(p []byte) (n int, err error)
default Close() error {
    return nil
}

}

Dans cet exemple, l'interface Reader définit la méthode Read et une implémentation par défaut de la méthode Close. Si l'interface Reader est implémentée mais que la méthode Close n'est pas implémentée, le système utilisera la méthode Close par défaut.

Il convient de noter que si une interface définit une méthode d'implémentation par défaut, il vous suffit alors d'implémenter la méthode autre que celle par défaut lors de l'implémentation de l'interface. Si vous souhaitez remplacer la méthode d'implémentation par défaut, vous pouvez définir une méthode du même nom dans la structure qui implémente l'interface pour remplacer l'implémentation par défaut.

Scénarios d'application pour l'implémentation par défaut de l'interface

Les scénarios d'utilisation pour l'implémentation par défaut de l'interface sont très larges. Ci-dessous, nous présenterons plusieurs scénarios d'application courants.

1. Imbrication d'interface

En langage Go, l'imbrication d'interface est une technologie très courante. Les interfaces imbriquées peuvent rendre le code plus flexible et mieux organisé.

Supposons que nous ayons une interface qui doit lire et écrire des fichiers :

type FileReadWrite interface {

Read(p []byte) (n int, err error)
Write(p []byte) (n int, err error)

}

Maintenant, nous définissons une interface qui doit fermer les fichiers :

type Closeable interface {

Close() error

}

Si nous voulons définir une interface d'opération de fichier, y compris les méthodes de lecture, d'écriture et de fermeture de fichier, vous pouvez utiliser des interfaces imbriquées :

type FileOperation interface {

FileReadWrite
Closeable

}

L'utilisation de l'implémentation par défaut peut éviter la duplication des implémentations lors de l'implémentation de FileOperation Interface Méthode de fermeture.

2. Mise à niveau de la version de l'interface

Au cours du processus de développement, des mises à niveau de la version de l'interface sont souvent rencontrées. Lorsque nous devons ajouter des méthodes à une interface, si nous modifions directement l'interface d'origine, tout le code qui a implémenté l'interface devra être modifié.

En utilisant l'implémentation par défaut, nous pouvons ajouter de nouvelles méthodes à l'interface sans casser le code existant. Si vous devez utiliser une nouvelle méthode, vous pouvez remplacer la méthode d'implémentation par défaut dans la structure qui implémente l'interface.

3. Modèle d'adaptateur d'interface

Le modèle d'adaptateur est un modèle de conception courant qui est utilisé pour convertir l'interface d'une classe en une autre interface afin de faciliter l'interaction entre les classes qui ne prennent pas en charge l'interface.

En langage Go, nous pouvons utiliser l'implémentation par défaut de l'interface pour implémenter rapidement le modèle d'adaptateur. Voici un exemple simple :

type USB interface {

Connect()
DataTransfer(data string) string

}

type Adaptee struct {}

func (a *Adaptee) OldInterface() {

fmt.Println("support old interface")

}

type Adapter interface {

USB

}

type AdapterImpl struct {

Adaptee

}

func (a *AdapterImpl) Connect() {

fmt.Println("connect USB")

}

func (a *AdapterImpl) DataTransfer(data string) string {

fmt.Println("transfer data through USB")
a.OldInterface()  
return "Result"

}

Dans cet exemple, nous avons défini une interface USB, et également défini une ancienne interface Adaptee pour démontrer l'utilisation de l'adaptateur. Afin de permettre à Adaptee d'utiliser l'interface USB, nous définissons un adaptateur qui implémente l'interface Adaptateur.

Connect et DataTransfer dans l'adaptateur utilisent l'implémentation par défaut. La méthode OldInterface d'Adaptee est appelée dans l'implémentation par défaut. De cette façon, nous pouvons utiliser un adaptateur pour convertir une classe qui ne prend pas en charge l'interface USB en une classe qui prend en charge l'interface USB.

Résumé

L'implémentation par défaut des interfaces en langage Go est une fonctionnalité du langage très pratique. Cela nous permet de définir les interfaces de manière plus flexible, tout en réduisant la duplication de code et en améliorant la qualité du code. Grâce à l'utilisation de l'implémentation par défaut de l'interface, nous pouvons plus facilement implémenter des modèles de conception tels que la réutilisation et le modèle d'adaptateur.

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!