Interface-Einbettung
Interfaces zusammensetzen
Interface-Einbettung ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Interfaces zusammensetzen
Interfaces können andere Interfaces einbetten und ihre Methodensätze zu einem größeren Vertrag verbinden. Die Standardbibliothek nutzt dies überall.
Syntax der Einbettung
Listen Sie einen Interface-Typ innerhalb eines anderen Interfaces auf, um alle seine Methoden einzubeziehen.
package main
import "fmt"
type Reader interface{ Read() string }
type Writer interface{ Write(s string) }
type ReadWriter interface {
Reader
Writer
}
func main() {
var rw ReadWriter
fmt.Println(rw == nil)
}io.ReadWriter in der Praxis
Das klassische Beispiel ist io.ReadWriter, das durch die Einbettung von io.Reader und io.Writer definiert ist. Jeder Typ mit beiden Methoden erfüllt diese Schnittstelle.
Eine zusammengesetzte Schnittstelle erfüllen
Ein konkreter Typ implementiert die kombinierte Schnittstelle einfach dadurch, dass er alle erforderlichen Methoden besitzt.
package main
import "fmt"
type Reader interface{ Read() string }
type Writer interface{ Write(s string) }
type ReadWriter interface {
Reader
Writer
}
type File struct{ data string }
func (f *File) Read() string { return f.data }
func (f *File) Write(s string) { f.data = s }
func main() {
var rw ReadWriter = &File{}
rw.Write("hi")
fmt.Println(rw.Read())
}Warum Interfaces zusammensetzen
Kleine Interfaces lassen sich leicht implementieren und testen. Durch das Zusammensetzen entstehen größere Verträge nur dort, wo sie benötigt werden, sodass jedes einzelne Teil minimal bleibt.
Aus kleinen Teilen aufbauen
Definieren Sie fokussierte Schnittstellen mit nur einer Methode und kombinieren Sie sie anschließend.
package main
import "fmt"
type Opener interface{ Open() }
type Closer interface{ Close() }
type OpenCloser interface {
Opener
Closer
}
type Door struct{}
func (Door) Open() { fmt.Println("opened") }
func (Door) Close() { fmt.Println("closed") }
func main() {
var oc OpenCloser = Door{}
oc.Open()
oc.Close()
}Keine doppelten Methoden
Eingebettete Interfaces dürfen keine überlappenden Methoden mit widersprüchlichen Signaturen beitragen; identische Methodensätze sind in aktuellem Go unproblematisch.
Schmale Interfaces akzeptieren
Funktionen sollten die kleinstmögliche benötigte Schnittstelle verlangen. Nehmen Sie io.Reader statt io.ReadWriteCloser, wenn Sie nur lesen.
package main
import "fmt"
type Reader interface{ Read() string }
func dump(r Reader) { fmt.Println(r.Read()) }
type Buf struct{}
func (Buf) Read() string { return "data" }
func main() {
dump(Buf{})
}Die io-Familie
Die Standardbibliothek kombiniert Reader, Writer und Closer zu ReadCloser, WriteCloser und ReadWriteCloser – einem klar strukturierten Netz von Verträgen.
Zusammengesetzte Interfaces in APIs
Geben Sie das umfassendste Interface zurück, das ein Wert unterstützt, akzeptieren Sie aber das schmalste, das Ihre Funktion verwendet. So maximieren Sie sowohl Flexibilität als auch Klarheit.
Interface- und Struct-Einbettung
- Die Struct-Einbettung promotiert Felder und Methoden, um Verhalten wiederzuverwenden
- Die Interface-Einbettung verbindet Methodenanforderungen zu einem größeren Vertrag
Kurztest
Testen Sie Ihr Wissen über die Einbettung von Interfaces.
Zusammenfassung
Sie haben die Einbettung von Interfaces kennengelernt.
- Interfaces innerhalb eines anderen auflisten, um Methodensätze zusammenzuführen
- Das Paket io kombiniert Reader, Writer und Closer
- Basisschnittstellen klein halten und nur bei Bedarf zusammensetzen
- Die schmalste von einer Funktion benötigte Schnittstelle akzeptieren
Häufig gestellte Fragen
Ist die Lektion „Interface-Einbettung“ kostenlos?
Ja — der vollständige Text von „Interface-Einbettung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Interface-Einbettung“?
Interfaces zusammensetzen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Go Academy zu starten?
Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Interface-Einbettung“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?
Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Struct-Einbettung
- Interface-Einbettung
- Methoden-Promotion
- Komposition statt Vererbung