Interfaces definieren und implementieren
Implizite Erfüllung und das leere Interface
Interfaces definieren und implementieren ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Was ist ein Interface?
Ein Interface in Go ist eine Menge von Methodensignaturen. Jeder Typ, der alle diese Methoden implementiert, erfüllt das Interface implizit – das Schlüsselwort implements ist nicht erforderlich. Dies wird strukturelle Typisierung oder Duck-Typing genannt.
Ein Interface deklarieren
Definieren Sie ein Interface mit dem Schlüsselwort type:
package main
import "fmt"
type Shape interface {
Area() float64
Perimeter() float64
}
type Circle struct{ Radius float64 }
func (c Circle) Area() float64 { return 3.14159 * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * 3.14159 * c.Radius }
func main() {
var s Shape = Circle{5}
fmt.Printf("Area: %.2f\n", s.Area())
}Implizite Erfüllung
Eine Absichtserklärung ist nicht erforderlich. Wenn ein Typ über die richtigen Methoden verfügt, erfüllt er das Interface automatisch:
package main
import "fmt"
type Greeter interface{ Greet() string }
type English struct{}
func (e English) Greet() string { return "Hello" }
type Spanish struct{}
func (s Spanish) Greet() string { return "Hola" }
func say(g Greeter) { fmt.Println(g.Greet()) }
func main() {
say(English{})
say(Spanish{})
}Das leere Interface
interface{} (oder any ab Go 1.18) wird von jedem Typ erfüllt. Es wird verwendet, wenn der Typ zur Kompilierzeit unbekannt ist:
package main
import "fmt"
func printAny(v any) { fmt.Printf("%T: %v\n", v, v) }
func main() {
printAny(42)
printAny("hello")
printAny([]int{1,2,3})
}Interface-Werte
Ein Interface-Wert enthält zwei Dinge: einen konkreten Typ und einen konkreten Wert. Bei einem nil-Interface sind beide auf nil gesetzt:
package main
import "fmt"
type Animal interface{ Sound() string }
type Dog struct{}
func (d Dog) Sound() string { return "woof" }
func main() {
var a Animal
fmt.Println(a == nil) // true
a = Dog{}
fmt.Println(a == nil) // false
fmt.Println(a.Sound())
}Mehrfache Interface-Erfüllung
Ein Typ kann mehrere Interfaces gleichzeitig erfüllen:
package main
import "fmt"
type Reader interface{ Read() string }
type Writer interface{ Write(string) }
type ReadWriter interface{ Reader; Writer }
type File struct{ content string }
func (f *File) Read() string { return f.content }
func (f *File) Write(s string) { f.content = s }
func main() {
var rw ReadWriter = &File{}
rw.Write("hello")
fmt.Println(rw.Read())
}Interface-Zuweisung
Ein weiter gefasstes Interface kann einen konkreten Wert mit engerem Typ enthalten. Die Zuweisung zwischen Interface-Typen setzt voraus, dass der konkrete Typ beide Interfaces erfüllt:
package main
import "fmt"
type Stringer interface{ String() string }
type Point struct{ X, Y int }
func (p Point) String() string { return fmt.Sprintf("(%d,%d)", p.X, p.Y) }
func main() {
var s Stringer = Point{3, 4}
fmt.Println(s.String())
}Die Falle des nil-Interfaces
Ein nicht nil-Interface, das einen konkreten nil-Wert enthält, ist NICHT gleich nil:
package main
import "fmt"
type MyErr struct{}
func (e *MyErr) Error() string { return "oops" }
func bad() error {
var e *MyErr // nil pointer
return e // returns non-nil interface!
}
func main() {
err := bad()
fmt.Println(err == nil) // false — common gotcha
}Interfaces ermöglichen Testbarkeit
Wenn Abhängigkeiten als Interfaces definiert werden, lassen sich echte Implementierungen in Tests durch Mocks ersetzen:
package main
import "fmt"
type EmailSender interface{ Send(to, body string) error }
type MockSender struct{ Sent []string }
func (m *MockSender) Send(to, body string) error {
m.Sent = append(m.Sent, to)
return nil
}
func notify(s EmailSender, addr string) { s.Send(addr, "hello") }
func main() {
mock := &MockSender{}
notify(mock, "a@b.com")
fmt.Println(mock.Sent) // [a@b.com]
}Interfaces akzeptieren, Structs zurückgeben
Eine bewährte Vorgehensweise in Go: Funktionsparameter sollten Interfaces sein (für Flexibilität), Rückgabetypen konkrete Typen (damit Aufrufer wissen, was sie erhalten):
package main
type Logger interface{ Log(string) }
type FileLogger struct{}
func (f *FileLogger) Log(s string) {}
func NewFileLogger() *FileLogger { // returns concrete
return &FileLogger{}
}
func process(l Logger) {} // accepts interface
func main() { process(NewFileLogger()) }Interfaces klein halten
Die Go-Standardbibliothek bevorzugt kleine Interfaces: io.Reader hat eine Methode, io.Writer hat eine Methode. Kleine Interfaces lassen sich besser kombinieren und einfacher mocken.
Kurztest
Muss ein Typ deklarieren, dass er ein Interface implementiert?
Zusammenfassung: Interfaces
Wichtige Erkenntnisse:
- Interfaces definieren Verhalten, nicht Daten
- Die Erfüllung erfolgt implizit – es gibt kein Schlüsselwort
implements - Das leere Interface (
any) akzeptiert jeden Typ - Achten Sie auf die Falle des nil-Interfaces
- Halten Sie Interfaces klein und fokussiert
Übungsaufgabe
Definieren Sie ein Storage-Interface mit Save(key, value string) error und Load(key string) (string, error). Implementieren Sie es mit einem MemStorage, das auf einer Map basiert, und testen Sie es.
Lerne Go mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „Interfaces definieren und implementieren“ kostenlos?
Ja — der vollständige Text von „Interfaces definieren und implementieren“ 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 „Interfaces definieren und implementieren“?
Implizite Erfüllung und das leere Interface 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 1 von 4.
Wie lange dauert die Lektion „Interfaces definieren und implementieren“?
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
- Interfaces definieren und implementieren
- Zentrale Interfaces der Standardbibliothek
- Typ-Assertions und Type-Switches
- Interface-Komposition und Best Practices