Interface-embedding
Stel interfaces samen
Interface-embedding is een gratis Go Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.
Interfaces combineren
Interfaces kunnen andere interfaces inbedden en zo hun methodesets combineren tot een groter contract. De standaardbibliotheek gebruikt dit overal.
Syntaxis voor inbedding
Vermeld een interfacetype in een andere interface om al zijn methoden op te nemen.
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 de praktijk
Het klassieke voorbeeld is io.ReadWriter, dat is gedefinieerd door io.Reader en io.Writer in te bedden. Elk type met beide methoden voldoet eraan.
Voldoen aan een gecombineerde interface
Een concreet type implementeert de gecombineerde interface eenvoudigweg door alle vereiste methoden te hebben.
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())
}Waarom je interfaces combineert
Kleine interfaces zijn eenvoudig te implementeren en te testen. Door ze te combineren bouw je alleen waar nodig grotere contracten, terwijl elk onderdeel minimaal blijft.
Bouwen uit kleine onderdelen
Definieer gerichte interfaces met één methode en combineer ze daarna.
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()
}Geen dubbele methoden
Ingebedde interfaces mogen geen overlappende methoden met tegenstrijdige handtekeningen aanleveren; identieke methodesets zijn in moderne Go wel toegestaan.
Smalle interfaces accepteren
Functies moeten om de kleinste interface vragen die ze nodig hebben. Accepteer io.Reader en niet io.ReadWriteCloser als je alleen leest.
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{})
}De io-familie
De standaardbibliotheek combineert Reader, Writer en Closer tot ReadCloser, WriteCloser en ReadWriteCloser — een overzichtelijk netwerk van contracten.
Gecombineerde interfaces in API's
Retourneer de breedste interface die een waarde ondersteunt, maar accepteer de smalste interface die je functie gebruikt. Zo maximaliseer je zowel flexibiliteit als duidelijkheid.
Interface-inbedding tegenover struct-inbedding
- Struct-inbedding maakt velden en methoden beschikbaar om gedrag te hergebruiken
- Interface-inbedding combineert methodevereisten tot een groter contract
Korte controle
Test je kennis van interface-inbedding.
Samenvatting
Je hebt interface-inbedding geleerd.
- Vermeld interfaces in een andere interface om methodesets samen te voegen
- Het io-pakket combineert Reader, Writer en Closer
- Houd basisinterfaces klein en combineer ze waar nodig
- Accepteer de smalste interface die een functie nodig heeft
Leer Go met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 51
- Lessen
- 203
Veelgestelde vragen
Is de les “Interface-embedding” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Interface-embedding”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.
Wat leer ik in “Interface-embedding”?
Stel interfaces samen Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Go Academy te beginnen?
Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Interface-embedding”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Go Academy?
Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Structembedding
- Interface-embedding
- Method promotion
- Compositie boven overerving