Qu'est-ce qu'une interface dans Golang

golang Qu'est-ce qu'une interface ?

Si goroutine et canal sont les deux pierres angulaires de la concurrence Go, alors les interfaces sont la clé des types de données dans la programmation en langage Go. Dans la programmation actuelle du langage Go, presque toutes les structures de données tournent autour des interfaces, et les interfaces sont au cœur de toutes les structures de données du langage Go.

Recommandations associées : Tutoriel golang

Interface en golang

Interface

Concept : Une interface définit un ensemble de méthodes, mais ne contient pas d'implémentations spécifiques de ces méthodes, elles sont abstraites et les interfaces ne peuvent pas contenir de variables ;

Format de définition de l'interface

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

2. Un exemple d'interface

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

L'interface en Golang rend le codage plus flexible et plus facile à réaliser. expand , ce qui fait que Go possède les caractéristiques du polymorphisme orienté objet.

Il nous suffit de retenir ici trois points :

● Collection des déclarations de méthode

● Tout type d'objet implémente tout ce qui est déclaré dans la méthode d'interface, indiquant que le type implémente l'interface correspondante.

Quantity peut être utilisé comme type de données, et tout objet qui implémente cette interface peut attribuer des valeurs aux variables de type d'interface correspondantes.

Utilisez des exemples pour comprendre les trois points ci-dessus :

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

Tant qu'un type implémente la méthode déclarée par l'interface, il est considéré comme ayant implémenté l'interface. implémentation de plusieurs interfaces en même temps. Une interface peut également être implémentée par plusieurs types. Si un type implémente une interface, alors les objets de ce type peuvent être affectés à des variables de ce type d'interface.

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

La dernière partie explique le type interface{} Ce type d'interface ne déclare aucune méthode, communément appelée interface vide. Parce que tout type d'objet implémente l'interface vide par défaut (comme mentionné ci-dessus, tant que n'importe quel type implémente la méthode d'interface, il implémentera l'interface correspondante. Puisque l'interface vide n'a pas de méthode, tous les types implémentent l'interface vide par défaut) . Lorsque vous en avez besoin Très utile dans le contexte des variables de type.

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!