So erstellen und richten Sie Schnittstellen in Golang ein (eine kurze Analyse der Methoden)

In Golang ist Schnittstelle ein Typ, der das Verhalten von Objekten beschreibt. Durch die Definition von Schnittstellen können wir die Funktionen und Interaktionsmethoden von Objekten standardisieren, um die Interaktion verschiedener Objekttypen zu erleichtern.

In Golang besteht der Methodensatz einer Schnittstelle aus einer Reihe von Methodendefinitionen. Der Typ, der die Schnittstelle implementiert, muss alle Methoden der Schnittstelle implementieren. Bei der Implementierung einer Schnittstelle müssen wir jedoch weder die Implementierung einer Schnittstelle explizit deklarieren noch eine Klasse erben oder eine Schnittstelle implementieren. Wir müssen nur den Methodensatz der Schnittstelle implementieren. Die Schnittstelle wird in Form eines dynamischen Versands implementiert, der eine gute Flexibilität und Skalierbarkeit aufweist.

Wie erstellt und richtet man also Schnittstellen in Golang ein? Als nächstes werden wir es unter den folgenden Gesichtspunkten vorstellen.

1. Schnittstelle definieren

Zuerst müssen wir die Schnittstelle definieren, den Schnittstellentyp definieren, indem wir das Schlüsselwort „type“ zur Schnittstelle hinzufügen, und den Methodensatz der Schnittstelle in Klammern definieren, zum Beispiel:

type MyInterface interface {
    Method1() string
    Method2() int
}

Der obige Code definiert eine Schnittstelle mit dem Namen Der Schnittstellentyp MyInterface enthält zwei Methoden, Methode1 und Methode2. Beachten Sie, dass die in der Schnittstelle definierten Methoden keine spezifischen Implementierungskörper haben, sondern nur den Methodennamen und den Rückgabewerttyp.

2. Implementieren Sie die Schnittstelle

Als nächstes müssen wir die Schnittstelle implementieren, indem wir einen Strukturtyp definieren, der den Schnittstellenmethodensatz implementiert, zum Beispiel:

type MyStruct struct{}

func (m MyStruct) Method1() string{
    return "Method1 is called."
}

func (m MyStruct) Method2() int{
    return 100
}

Der obige Code definiert einen Strukturtyp namens MyStruct, der die beiden Methoden implementiert der MyInterface-Schnittstelle, Method1 und Method2. Es ist zu beachten, dass die Methode, die die Schnittstelle implementiert, den Methodennamen, die Parameterliste und den Rückgabewerttyp verwenden muss, die genau mit den in der Schnittstelle definierten übereinstimmen, um als Implementierung der Schnittstelle erkannt zu werden. In diesem Beispiel implementiert der im MyStruct-Typ festgelegte Methodensatz auch den Methodensatz von MyInterface, dh die MyInterface-Schnittstelle wird implementiert.

3. Schnittstellen verwenden

Die Verwendung von Schnittstellen ist die grundlegendste Operation im Zusammenhang mit Schnittstellen in Golang. Durch die Definition einer Variablen des Schnittstellentyps können wir diese Variable verschiedenen Typen zuweisen, die die Schnittstelle implementieren, zum Beispiel:

var i MyInterface
i = MyStruct{}

fmt.Println(i.Method1())
fmt.Println(i.Method2())

Above The Code definiert eine Variable i vom Typ MyInterfce und weist ihr eine Variable vom Typ MyStruct zu. Da der MyStruct-Typ die MyInterface-Schnittstelle implementiert, kann ich auf alle in MyInterface definierten Methoden zugreifen. Das Ausgabeergebnis lautet:

Method1 is called.
100

Es ist zu beachten, dass dies tatsächlich der Fall ist, wenn wir eine Variable vom Typ MyStruct einer Variablen vom Typ MyInterface zuweisen Eine Kopie des Werts vom Typ MyStruct wird der Variablen i vom Typ MyInterface zugewiesen, was der Implementierung virtueller Funktionen in C++ ähnelt. Seien Sie daher vorsichtig, wenn Sie Zeigertypen zum Implementieren von Schnittstellen verwenden, denn wenn sich das Objekt, auf das eine Zeigertypvariable zeigt, ändert, kann dies Auswirkungen auf die Verfügbarkeit der Schnittstellenimplementierung haben.

4. Verschachtelung von Schnittstellen

In Golang unterstützen Schnittstellen auch die Verschachtelung, also die Verschachtelung anderer Schnittstellentypen als Methodensätze in der Schnittstelle. Zum Beispiel:

type MyInterface1 interface {
    Method1() string
}

type MyInterface2 interface {
    MyInterface1
    Method2() int
}

type MyStruct struct{}

func (m MyStruct) Method1() string{
    return "Method1 is called."
}

func (m MyStruct) Method2() int{
    return 100
}

func main() {
    var i MyInterface2
    i = MyStruct{}

    fmt.Println(i.Method1())
    fmt.Println(i.Method2())
}

Der obige Code definiert eine MyInterface2-Schnittstelle, die eine verschachtelte MyInterface1-Schnittstelle definiert und die Methoden der MyInterface1- und MyInterface2-Schnittstellen implementiert. Der MyStruct-Typ implementiert auch diese beiden Schnittstellen, sodass er i- und call-Methoden zugewiesen werden kann.

5. Leere Schnittstelle

Wenn wir in Golang den spezifischen Typ eines Objekts nicht kennen, es aber dennoch bearbeiten möchten, können wir es dennoch mithilfe von Schnittstellen vervollständigen. Dies ist das Konzept der leeren Schnittstelle. Die leere Schnittstelle ist ein spezieller Typ in Golang. Ihr Methodensatz ist leer und kann jeden Objekttyp darstellen. Zum Beispiel:

var i interface{}
i = 1

fmt.Println(i)

Der obige Code definiert eine Variable i vom Typ interface{} und weist ihr dann die Ganzzahl 1 zu. Da der Typ interface{} jeden Objekttyp darstellen kann, können wir den Wert von i ausgeben und das richtige Ergebnis erhalten.

Die oben genannten sind die grundlegenden Methoden zum Erstellen und Festlegen von Schnittstellen in Golang. Die Beherrschung der Verwendung von Schnittstellen kann den Code flexibler und skalierbarer machen und die Lesbarkeit und Wartbarkeit des Programms verbessern.

Das obige ist der detaillierte Inhalt vonSo erstellen und richten Sie Schnittstellen in Golang ein (eine kurze Analyse der Methoden). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!