Was ist eine Schnittstelle in Golang?

golang Was ist eine Schnittstelle?

Wenn Goroutine und Kanal die beiden Eckpfeiler der Go-Parallelität sind, dann sind Schnittstellen der Schlüssel zu Datentypen in der Go-Sprachprogrammierung. Bei der eigentlichen Programmierung der Go-Sprache drehen sich fast alle Datenstrukturen um Schnittstellen, und Schnittstellen sind der Kern aller Datenstrukturen in der Go-Sprache.

Verwandte Empfehlungen: Golang-Tutorial

Schnittstelle in Golang

1. Schnittstelle

Konzept: Eine Schnittstelle definiert eine Reihe von Methoden, enthält jedoch keine spezifischen Implementierungen dieser Methoden. Sie sind abstrakt und Schnittstellen können keine Variablen enthalten.

Definitionsformat der Schnittstelle

type Namer interface {
method1() return_type
method2() return_type
}

2. Ein Beispiel einer Schnittstelle

    package main
    import "fmt"
    
    type Message interface {
        Send()
    }
    type user struct {
        name string
        score int
    }
    func (u *user) Send() {
        fmt.Println("hi", u.name, "this is your ", u.score)
    }
    func sendMessage(msg Message) {
        msg.Send()
    }
    func main() {
        u := &user{name: "roty", score: 44}
        sendMessage(&u)
    }

Die Schnittstelle in Golang macht das Codieren flexibler und einfacher erweitern, wodurch Go die Eigenschaften eines objektorientierten Polymorphismus besitzt.

Es genügt uns, sich hier an drei Punkte zu erinnern:

● Sammlung von Methodendeklarationen

● Jeder Objekttyp implementiert alles, was in der Schnittstellenmethode deklariert ist. Gibt an, dass der Typ die entsprechende Schnittstelle implementiert.

● kann als Datentyp verwendet werden, und jedes Objekt, das diese Schnittstelle implementiert, kann den entsprechenden Schnittstellentypvariablen Werte zuweisen.

Verwenden Sie Beispiele, um die oben genannten drei Punkte zu verstehen:

package main
import "fmt"
import "math"
// 几何图形的接口(interface)
type geometry interface {
    area() float64
    perim() float64
}
// rect 和 circle 实现 geometry 接口
type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}
// 实现了接口中声明的所有方法即实现了该接口，这里 rects 实现了 geometry 接口
func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}
// circles 实现 geometry 接口
func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}
// 定义的接口可以作为一种数据类型，当一个变量的类型为一个接口类型时，这个变量可以调用接口中定义的方法。
// 这里定义一个函数，接收一个类型为 geometry 的参数变量
func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}
func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}
    // The circle and rect struct types both implement the geometry interface so we can use instances of these structs as arguments to measure.
    // rect 和 circle 结构类型都实现了 geometry 接口，所以我们能够把它们的对象作为参数传给 measure 函数
    // 在 measure 函数内部，参数对象调用了所属类型实现的接口方法。
    measure(r)
    measure(c)
}

Solange ein Typ die von der Schnittstelle deklarierte Methode implementiert, wird davon ausgegangen, dass er die Schnittstelle implementiert hat. Derselbe Typ kann die unterstützen Implementierung mehrerer Schnittstellen gleichzeitig. Eine Schnittstelle kann auch von mehreren Typen implementiert werden. Wenn ein Typ eine Schnittstelle implementiert, können Objekte dieses Typs Variablen dieses Schnittstellentyps zugewiesen werden.

package main
import "fmt"
type I interface {
  method1()
}
type T struct{}
func (T) method1()  {}
func main()  {
  var i I = T{}
  fmt.Println(i)
}

Im letzten Teil wird der Typ interface{} erläutert. Dieser Schnittstellentyp deklariert keine Methoden und wird allgemein als leere Schnittstelle bezeichnet. Da jeder Objekttyp standardmäßig die leere Schnittstelle implementiert (wie oben erwähnt, implementiert jeder Typ, solange er die Schnittstellenmethode implementiert, die entsprechende Schnittstelle. Da die leere Schnittstelle keine Methode hat, implementieren alle Typen standardmäßig die leere Schnittstelle.) . Wenn Sie etwas benötigen, das im Zusammenhang mit Typvariablen sehr nützlich ist.

package main
import (
    "fmt"
)
func PrintAll(vals []interface{}) {
    for _, val := range vals {
        fmt.Println(val)
    }
}
func main() {
    names := []string{"stanley", "david", "oscar"}
    vals := make([]interface{}, len(names))
    for i, v := range names {
        vals[i] = v
    }
    PrintAll(vals)
}
// stanley
// david
// oscar

Das obige ist der detaillierte Inhalt vonWas ist eine Schnittstelle in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!