Heim  >  Artikel  >  Backend-Entwicklung  >  Kann Go Language Schnittstellen entwickeln?

Kann Go Language Schnittstellen entwickeln?

青灯夜游
青灯夜游Original
2022-12-15 18:49:415453Durchsuche

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. .}".

Kann Go Language Schnittstellen entwickeln?

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.

Konzept

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.

Schnittstellendefinition

type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}

In der Go-Sprache verwenden wir das Schlüsselwort „interface“, um die Schnittstelle zu definieren.

Bedingungen für die Schnittstellenimplementierung

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()
}

Wenn der Xiaomi-Typ nur eine Methode in der Schnittstelle implementiert, kompilieren wir sie bei Verwendung Melden Sie einen Fehler.

Kann Go Language Schnittstellen entwickeln?Die Beziehung zwischen Typen und Schnittstellen

Ein Typ implementiert mehrere Schnittstellen

Ein Typ kann mehrere Schnittstellen implementieren, und die Schnittstellen sind unabhängig voneinander und kennen die Implementierung voneinander nicht.

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()
}
Zum Beispiel können sich Hunde bewegen, und auch Autos können sich bewegen. Sie können den folgenden Code verwenden, um diese Beziehung zu erreichen:

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()
    }

Leere Schnittstelle

Leere Schnittstelle: Schnittstelle{}, enthält keine Methoden. Aus diesem Grund implementiert jeder Typ die leere Schnittstelle, sodass die leere Schnittstelle jede Art von Daten speichern kann.

Serienfunktionen, die meisten ihrer Parameter sind leere Schnittstellentypen, von denen man auch sagen kann, dass sie jeden Typ unterstützen

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)
Die leere Schnittstelle wird als Wert der Karte verwendet

// 空接口作为map值
    var studentInfo = make(map[string]interface{})
    studentInfo["name"] = "李白"
    studentInfo["age"] = 18
    studentInfo["married"] = false
    fmt.Println(studentInfo)
fmt 包下的 PrintTypinferenz

Die leere Schnittstelle kann jede Art von Wert speichern. Was machen wir also mit dem Abrufen der spezifischen Daten, die darin gespeichert sind? Schnittstellenwert

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{}

  • darstellt

    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语言中的使用十分广泛。

总结

关于接口需要注意的是,只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口,那样只会增加不必要的抽象,导致不必要的运行时损耗。

【相关推荐: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!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn