Go-Sprache kann Schnittstellen entwickeln. Die Schnittstelle in der Go-Sprache ist die Signatur einer Reihe von Methoden. Sie ist ein wichtiger Teil der Go-Sprache. Die Aufgabe der Schnittstelle ist wie die Definition einer Spezifikation oder eines Protokolls. Das Schlüsselwort interface wird in der Go-Sprache verwendet, um die Schnittstelle zu definieren. Die Syntax lautet „Typ Schnittstelle Typname Schnittstelle{Methodenname 1 (Parameterliste 1) Rückgabewertliste 1 Methodenname 2 (Parameterliste 2) Rückgabewertliste 2. .}".
Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.
Schnittstelle sollte für uns ein vertrautes Konzept sein. Für Programmierer wie uns, die sich besser mit Java auskennen, werfen wir einen Blick darauf, wie Schnittstellen in der Go-Sprache verwendet werden und welche Rolle Schnittstellen in der täglichen Entwicklung spielen.
In der Go-Sprache ist die Schnittstelle die Signatur einer Reihe von Methoden. Sie ist ein wichtiger Teil der Go-Sprache. Was die Schnittstelle tut, ist wie die Definition einer Spezifikation oder eines Protokolls um es gemäß dem Protokoll umzusetzen.
Schnittstelle ist ein Typ
Schnittstellentyp ist eine Abstraktion und Verallgemeinerung des Verhaltens anderer Typen. Diese abstrakte Methode kann unsere Funktionen flexibler machen.
type 接口类型名 interface{
方法名1( 参数列表1 ) 返回值列表1
方法名2( 参数列表2 ) 返回值列表2
…
}In der Go-Sprache verwenden wir das Schlüsselwort „interface“, um die Schnittstelle zu definieren.
Wenn der Methodensatz eines beliebigen Typs T eine Obermenge des Methodensatzes eines Schnittstellentyps ist, dann sagen wir, dass Typ T die Schnittstelle implementiert.
Die Implementierung der Schnittstelle ist in der Go-Sprache implizit, was bedeutet, dass die Implementierungsbeziehung zwischen den beiden Typen nicht im Code widergespiegelt werden muss. In der Go-Sprache gibt es kein ähnliches Schlüsselwort wie bei den Implementierungen in Java Der Go-Compiler überprüft bei Bedarf automatisch die Implementierungsbeziehung zwischen zwei Typen. Nachdem die Schnittstelle definiert wurde, muss sie implementiert werden, damit der Aufrufer die Schnittstelle korrekt kompilieren und verwenden kann.
Die Implementierung einer Schnittstelle muss zwei Regeln folgen, um die Schnittstelle verfügbar zu machen:
1 Die Methode der Schnittstelle hat dasselbe Format wie die Typmethode, die die Schnittstelle implementiert. Die Methode kann durch Hinzufügen einer Methode implementiert werden konsistent mit der Schnittstellensignatur im Typ. Die Signatur umfasst den Namen, die Parameterliste und die Rückgabeparameterliste der Methode. Mit anderen Worten: Solange der Name, die Parameterliste und die Rückgabeparameterliste der Methode im implementierten Schnittstellentyp nicht mit der von der Schnittstelle zu implementierenden Methode übereinstimmen, wird diese Methode der Schnittstelle nicht implementiert.
package main
import "fmt"
type Phone interface {
Call()
SendMessage()
}
type HuaWei struct {
Name string
Price float64
}
func (h *HuaWei) Call() {
fmt.Printf("%s:可以打电话",h.Name)
}
func (h *HuaWei) SendMessage() {
fmt.Printf("%s:可以发送短信",h.Name)
}
func main() {
h := new(HuaWei)
h.Name="华为"
var phone Phone
phone = h
phone.SendMessage()
}Wenn ein Typ eine Schnittstelle nicht implementieren kann, meldet der Compiler einen Fehler:
a. Fehler, die durch inkonsistente Funktionsnamen verursacht werden. b. Fehler, die durch inkonsistente Methodensignaturen zur Implementierung aller Methoden in der Schnittstelle verursacht werden werden implementiert, wenn eine Schnittstelle mehrere Methoden enthält. Nur wenn diese Methoden implementiert sind, kann die Schnittstelle kompiliert und korrekt verwendet werden.
func (h *Xiaomi) Call() {
fmt.Printf("%s:可以打电话",h.Name)
}
func main() {
h := new(Xiaomi)
h.Name="小米"
var phone Phone
phone = h
phone.SendMessage()
}
Die Beziehung zwischen Typen und Schnittstellen
Ein Typ implementiert mehrere Schnittstellen
Zum Beispiel kann sich ein Hund bewegen und
package main
import "fmt"
type Move interface {
move()
}
type Say interface {
say()
}
type Dog struct {
Name string
}
func (d *Dog) move() {
fmt.Printf("%s会动\n", d.Name)
}
func (d *Dog) say() {
fmt.Printf("%s会叫汪汪汪\n", d.Name)
}
func main() {
var m Move
var s Say
d:=&Dog{
Name: "旺财",
}
m = d
s=d
m.move()
s.say()
}Mehrere Typen implementieren dieselbe Schnittstelle
Verschiedene Typen in der Go-Sprache können auch dieselbe Schnittstelle implementieren. Zuerst definieren wir eine Mover-Schnittstelle, die dies erfordert Es muss eine Verschiebungsmethode geben. type Mover interface {
move()
}
type dog struct {
name string
}
type car struct {
brand string
}
// dog类型实现Mover接口
func (d dog) move() {
fmt.Printf("%s会跑\n", d.name)
}
// car类型实现Mover接口
func (c car) move() {
fmt.Printf("%s速度70迈\n", c.brand)
}Zu diesem Zeitpunkt können wir Hunde und Autos im Code als ein sich bewegendes Objekt behandeln, und nein Sie müssen nicht mehr darauf achten, was sie konkret sind. Sie müssen nur noch ihre Move-Methode aufrufen.
func main() {
var x Mover
var a = dog{name: "旺财"}
var b = car{brand: "保时捷"}
x = a
x.move()
x = b
x.move()
}func Print(a ...interface{}) (n int, err error)
func Println(format string, a ...interface{}) (n int, err error)
func Println(a ...interface{}) (n int, err error)// 空接口作为map值
var studentInfo = make(map[string]interface{})
studentInfo["name"] = "李白"
studentInfo["age"] = 18
studentInfo["married"] = false
fmt.Println(studentInfo)fmt 包下的 PrintTypinferenz
Ein Schnittstellenwert (als Schnittstellenwert bezeichnet) besteht aus einem bestimmten Typ und dem Wert des bestimmten Typs.
Diese beiden Teile werden als dynamischer Typ bzw. dynamischer Wert der Schnittstelle bezeichnet.
Wenn Sie den Wert in der leeren Schnittstelle beurteilen möchten, können Sie zu diesem Zeitpunkt die Typzusicherung verwenden. Das Syntaxformat lautet:
x.(T)
wobei:
x: eine Variable vom Typ Schnittstelle{}
T: stellt Behauptung x dar. Wahrscheinlich der Typ.
该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败。
func main() {
var x interface{}
x = "ms的go教程"
v, ok := x.(string)
if ok {
fmt.Println(v)
} else {
fmt.Println("类型断言失败")
}
}上面的示例中如果要断言多次就需要写多个if判断，这个时候我们可以使用switch语句来实现：
func justifyType(x interface{}) {
switch v := x.(type) {
case string:
fmt.Printf("x is a string，value is %v\n", v)
case int:
fmt.Printf("x is a int is %v\n", v)
case bool:
fmt.Printf("x is a bool is %v\n", v)
default:
fmt.Println("unsupport type！")
}
}因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。
关于接口需要注意的是，只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。
Das obige ist der detaillierte Inhalt vonKann Go Language Schnittstellen entwickeln?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Verwendung des Schlüsselworts Type in Go
So implementieren Sie eine verknüpfte Liste in Go
Was ist die Programmiersoftware für die Go-Sprache?
Einführung in Festplattenschnittstellentypen
Wie man Go-Sprache von Grund auf lernt
So definieren Sie Variablen in Golang
Welche Methoden gibt es, um eine Operatorüberladung in der Go-Sprache zu implementieren?
Was sind die Operatoren in der Go-Sprache?
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
