Maison > développement back-end > Golang > le corps du texte

Go et héritage : quand la composition surpasse-t-elle l'héritage pour la réutilisabilité du code ?

Susan Sarandon
Libérer: 2024-11-10 08:35:03
original
248 Les gens l'ont consulté

Go and Inheritance: When Does Composition Outshine Inheritance for Code Reusability?

Go et l'héritage : adopter la composition pour la réutilisabilité du code

Dans Go, l'extension des fonctionnalités au-delà des structures de base est souvent abordée en utilisant la composition au lieu de l'héritage. Cela garantit la clarté du code et minimise la duplication.

Considérez l'exemple suivant où l'objectif est de définir une structure de base avec des méthodes qui peuvent être étendues par d'autres structures :

type MyInterface interface {
  SomeMethod(string)
  OtherMethod(string)
}

type Base struct {
  B MyInterface
}

func (b *Base) SomeMethod(x string) {
  b.B.OtherMethod(x)
}

type Extender struct {
  Base
}

func (b *Extender) OtherMethod(x string) {
  // Do something...
}

func NewExtender() *Extender {
  e := Extender{}
  e.Base.B = &e
  return &e
}
Copier après la connexion

Pendant que cet exemple fonctionne , il semble alambiqué en raison de sa structure cyclique. Pour réduire la duplication de code et créer un code plus lisible, envisagez d'utiliser l'intégration.

L'intégration vous permet de composer des structures qui implémentent des interfaces spécifiques. Par exemple, vous pouvez créer des interfaces étroites pour la lecture et l'écriture :

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}
Copier après la connexion

En composant ces interfaces, vous pouvez créer une interface ReadWriter :

type ReadWriter interface {
    Reader
    Writer
}
Copier après la connexion

De même, vous pouvez composer des structures qui implémentez Reader et Writer dans une structure MyReadWriter :

type MyReader struct {}
func (r *MyReader) Read(p []byte) (n int, err error) {
    // Implements Reader interface.
}
type MyWriter struct {}
func (w *MyWriter) Write(p []byte) (n int, err error) {
    // Implements Writer interface.
}

type MyReadWriter struct {
    *MyReader
    *MyWriter
}
Copier après la connexion

La structure MyReadWriter implémente désormais l'interface ReadWriter, vous permettant d'utiliser n'importe quel composant qui implémente Reader ou Writer dans cette structure.

Cette intégration Cette technique favorise la réutilisabilité du code, l'injection de dépendances et facilite les tests en permettant l'échange de composants qui implémentent des interfaces spécifiques.

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal