Einführung
Interface als Menge von Methoden
In seiner einfachsten Form ist ein Interface-Typ eine Menge von Methodensignaturen.
Hier ist ein Beispiel für eine Interface-Definition, die zwei Methoden Add und Value enthält:
type Counter interface {
Add(increment int)
Value() int
}
Parameternamen wie increment können in der Interface-Definition weggelassen werden, aber sie erhöhen oft die Lesbarkeit.
Interface-Namen in Go enthalten nicht das Wort Interface oder I.
Stattdessen enden sie oft auf er, z. B. Reader, Stringer.
Ein Interface implementieren
Jeder Typ, der die Methoden des Interfaces definiert, „implementiert" das Interface automatisch implizit.
In Go gibt es kein implements-Schlüsselwort.
Der folgende Typ implementiert das Counter-Interface, das wir oben gesehen haben.
type Stats struct {
value int
// ...
}
func (s Stats) Add(v int) {
s.value += v
}
func (s Stats) Value() int {
return s.value
}
func (s Stats) SomeOtherMethod() {
// The type can have additional methods not mentioned in the interface.
}
Für die Implementierung des Interfaces spielt es keine Rolle, ob die Methode einen Wert- oder einen Pointer-Empfänger hat.
(Schau dir die Methoden-Konzepte noch einmal an, wenn du dir dabei unsicher bist.)
Ein Wert vom Interface-Typ kann jeden Wert halten, der diese Methoden implementiert. [^1]
Das bedeutet, dass Stats jetzt überall dort verwendet werden kann, wo das Counter-Interface erwartet wird.
func SetUpAnalytics(counter Counter) {
// ...
}
stats := Stats{}
SetUpAnalytics(stats)
// works because Stats implements Counter
Da Interfaces implizit implementiert werden, kann ein Typ leicht mehrere Interfaces implementieren.
Er muss nur alle notwendigen Methoden definiert haben.
Das leere Interface
In Go gibt es einen ganz besonderen Interface-Typ, den leeren Interface-Typ, der null Methoden enthält.
Das leere Interface wird so geschrieben: interface{}.
any ist ein Alias für interface{} und wird häufiger verwendet.
Da das leere Interface keine Methoden hat, implementiert es jeder Typ implizit.
Das ist hilfreich, um eine Funktion zu definieren, die generisch jeden Wert annehmen kann.
In diesem Fall verwendet der Funktionsparameter den leeren Interface-Typ.
Anleitung
Der neue Flughafen in Berlin hat Entwickler für sein Roboterlabor eingestellt, und du fängst dort deinen Job an.
Sie haben klobige, etwas humanoid aussehende Roboter, mit denen sie den Kundenservice verbessern wollen.
Die erste Aufgabe bei deiner Arbeit ist es, ein Programm zu schreiben, damit der Roboter Menschen in ihrer Muttersprache begrüßen kann, nachdem sie ihre Pässe am Self-Check-in-Schalter gescannt haben.
Der Roboter ist stolz auf seine Fähigkeiten, deshalb sagt er immer zuerst, welche Sprache er spricht, und begrüßt dann die Person.
Wenn zum Beispiel jemand einen deutschen Pass scannt, sagt der Roboter:
I can speak German: Hallo Dietrich!
1. Erstelle die abstrakte Begrüßungsfunktionalität
Den Code für die verschiedenen Sprachen wirst du nicht selbst schreiben, also musst du deinen Code für den Roboter so strukturieren, dass andere Entwickler später leicht weitere Sprachen hinzufügen können.
Definiere als ersten Schritt ein Interface Greeter mit zwei Methoden.
-
LanguageName, die den Namen der Sprache (einen string) zurückgibt, in der der Roboter den Besucher begrüßen soll.
-
Greet, die den Namen eines Besuchers (einen string) entgegennimmt und einen string mit der Begrüßungsnachricht in einer bestimmten Sprache zurückgibt.
Implementiere als Nächstes eine Funktion SayHello, die den Namen des Besuchers und alles, was das Interface Greeter implementiert, als Argumente entgegennimmt und den gewünschten Begrüßungsstring zurückgibt.
Stell dir zum Beispiel eine deutsche Greeter-Implementierung vor, bei der LanguageName "German" zurückgibt und Greet "Hallo {name}!" zurückgibt:
SayHello("Dietrich", germanGreeter)
// => "I can speak German: Hallo Dietrich!"
2. Implementiere Italienisch
Jetzt ist es deine Aufgabe, den Roboter für Menschen zum Laufen zu bringen, die italienische Pässe scannen.
Erstelle dazu ein Struct Italian und implementiere die beiden Methoden, die nötig sind, damit das Struct das Interface Greeter erfüllt, das du in Aufgabe 1 angelegt hast.
Mit "Ciao {name}!" kannst du jemanden auf Italienisch begrüßen.
3. Implementiere Portugiesisch
Bevor du Feierabend machst, sollst du außerdem die Funktionalität fertigstellen, um Menschen auf Portugiesisch zu begrüßen.
Erstelle dazu ein Struct Portuguese und implementiere auch hier die beiden Methoden, die nötig sind, damit das Struct das Interface Greeter erfüllt.
Mit "Olá {name}!" kannst du jemanden auf Portugiesisch begrüßen.
Lernübung
