Heim > Backend-Entwicklung > Golang > Einführung in die Golang-Schnittstelle

Einführung in die Golang-Schnittstelle

藏色散人
Freigeben: 2020-09-15 10:21:35
nach vorne
2617 Leute haben es durchsucht

Die folgende Kolumne stellt Ihnen die Golang-Benutzeroberfläche aus der Kolumne Golang-Tutorial vor. Ich hoffe, dass sie Freunden, die sie benötigen, hilfreich sein wird!

Einführung in die Golang-Schnittstelle

In der Go-Sprache ist die Schnittstelle ein Typ, ein abstrakter Typ.

Definition der Schnittstelle

Definitionsformat:

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

Bei der Benennung von Schnittstellen in der Go-Sprache wird normalerweise „er“ nach dem Wort hinzugefügt. Es ist am besten, wenn der Schnittstellenname die Typbedeutung der Schnittstelle hervorhebt.

Schnittstellenimplementierung

Solange ein Objekt alle Methoden in der Schnittstelle implementiert, implementiert es die Schnittstelle.
Verschiedene Typen in der Go-Sprache können dieselbe Schnittstelle implementieren. (Im Beispiel implementieren sowohl Hund als auch Katze die Animal-Schnittstelle.)

//定义一个Animal接口// Animal 是一个动物接口,实现move()和say()方法type Animal interface {
    move()
    say()
}//定义dog结构体type dog struct {
    name string
}//定义cat结构体type cat struct {
    name string
}//dog实现move方法func (d dog) move() {
    fmt.Printf("%s会跑\n",d.name)
}//dog实现say方法func (d dog) say() {
    fmt.Printf("%s会叫汪汪汪\n",d.name)
}//cat实现move方法func (c *cat) move() {
    fmt.Printf("%s会跑\n",c.name)
}//cat实现say方法func (c cat) say() {
    fmt.Printf("%s会叫喵喵喵\n",c.name)
}func main()  {    var a Animal    //声明一个Animal类型的a    //实例化一个dog结构体
    d := dog{name:"旺财"}
    fmt.Printf("%T\n", d)       //main.dog
    d.move()    //旺财会跑
    d.say()     //旺财会叫汪汪汪
    a = d // 接口是一种类型,一种抽象的类型。
    fmt.Println(a)  //{旺财}    //实例化一个cat结构体
    c := cat{name:"蓝猫"}
    c.move()    //蓝猫会跑
    c.say()     //蓝猫会叫喵喵喵
}
Nach dem Login kopieren

Polymorphismus

GO-Sprache simuliert Polymorphismus über Schnittstellen.

Beziehung zwischen Typen und Schnittstellen

Ein Typ kann mehrere Schnittstellen gleichzeitig implementieren, und die Schnittstellen sind unabhängig voneinander und kennen die Implementierung der anderen nicht.
Verschiedene Typen in der Go-Sprache können dieselbe Schnittstelle implementieren.

Schnittstellenverschachtelung

Neue Schnittstellen können durch Verschachtelung zwischen Schnittstellen erstellt werden.

//定义speaker接口type speaker interface {
    speak()
}//定义mover接口type mover interface {
    move()
}// 接口嵌套type animal interface {
    speaker
    mover
}//定义cat结构体type cat struct {
    name string
}//cat是值类型接收者func (c cat) speak() {
    fmt.Println("喵喵喵")
}func (c cat) move() {
    fmt.Println("猫会动")
}func main()  {    var x animal
    x = cat{name: "花花"}
    x.move()    //猫会动
    x.speak()   //喵喵喵
}
Nach dem Login kopieren

Leere Schnittstelle

Definition einer leeren Schnittstelle

Eine leere Schnittstelle bezieht sich auf eine Schnittstelle, die keine Methoden definiert. Variablen vom leeren Schnittstellentyp können Variablen jeden Typs speichern.

//空接口func main()  {    var x interface{}
    x = 100     //int类型
    fmt.Println(x)  //100
    x = "ares"  //string类型
    fmt.Println(x)  //ares
    x = struct {    //结构体类型
        name string
    }{name:"ares"}  //结构体赋值
    fmt.Println(x)  //ares
}
Nach dem Login kopieren

Leere Schnittstellenanwendung

Eine leere Schnittstelle kann als Funktionsparameter oder Kartenwert verwendet werden.

//空接口func showType(a interface{}) {
    fmt.Printf("type:%T\n", a)
}func main()  {    //空接口作为函数的参数
    showType(100)       //type:int
    showType("ares")    //type:string    //定义一个值为空接口的map    var stu = make(map[string]interface{},100)
    stu["ares"] = 100
    stu["ares1"] = "男"
    fmt.Println(stu)    //map[ares:100 ares1:男]    //map,key是字符串,value是任意类型
    map1 := make(map[string]interface{})
    map1["name"] = "ares"
    map1["age"] = 18
    map1["id"] = 1
    map1["friend"] = struct {
        name string
        age  int
    }{"jay", 33}
    fmt.Println(map1) //map[age:18 friend:{jay 33} id:1 name:ares]
    }
Nach dem Login kopieren

Schnittstellenverschachtelung

ähnelt der Vererbung.

type A interface {
    test1()
}type B interface {
    test2()
}type C interface {
    A
    B
    test3()
}type Cat struct { //如果要实现接口c,需要将接口a和接口b中的方法一起实现
}func (c Cat) test1() {
    fmt.Println("test1...")
}func (c Cat) test2() {
    fmt.Println("test2...")
}func (c Cat) test3() {
    fmt.Println("test3...")
}func main() {    var cat = Cat{}
    cat.test1() //test1...
    cat.test2() //test2...
    cat.test3() //test3...    //将cat赋值接口A类型,则只能使用test1方法    var cat1 A = Cat{}
    cat1.test1() //test1...    //将cat赋值接口B类型,则只能使用test2方法    var cat2 B = Cat{}
    cat2.test2() //test2...
}
Nach dem Login kopieren

Typzusicherung

Syntax:

x.(T)
Nach dem Login kopieren

x: Stellt eine Variable vom Typ Schnittstelle dar{}
T: Stellt den möglichen Typ der Zusicherung dar Wenn es falsch ist, weist dies auf einen Behauptungsfehler hin. Der Unterschied zwischen

//类型断言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)    case *string:
        fmt.Printf("x is a point指针 is %v\n", v)    case struct{}:
        fmt.Printf("x is a struct is %v\n", v)    default:
        fmt.Println("unsupport type!")
    }}func main()  {
    justifyType(100)        //x is a int is 100
    justifyType("ares") //x is a string,value is ares
    justifyType(false)  //x is a bool is false
    x := "ares"
    justifyType(&x) //x is a point指针 is 0xc000094010
    justifyType(struct {}{})    //x is a struct is {}
    justifyType([]int{123}) //unsupport type!
}
Nach dem Login kopieren
Wertempfänger und

ZeigerempfängerImplementierungsschnittstelleWenn der Empfänger ein Zeigertyp ist, kann der Wert nicht übergeben werden.
//定义animal接口type animal interface {
    speak()
    move()
}//定义cat结构体type cat struct{
    name string
}//定义dog结构体type dog struct{
    name string
}//值接收者
 func (c cat) speak() {
    fmt.Printf("%s会叫喵喵喵\n",c.name)
 } func (c cat) move() {
    fmt.Printf("%s会动\n",c.name)
 } //指针接收者func (d *dog) speak() {
    fmt.Printf("%s会叫汪汪汪\n",d.name)
}func (d *dog) move() {
    fmt.Printf("%s会动\n",d.name)
}func main()  {    var c1 animal
    lm := cat{name:"蓝猫"}
    c1 = lm     //因为实现animal接口的是cat值类型,所以可以直接赋值
    c1.move()   //蓝猫会动
    c1.speak()  //蓝猫会叫喵喵喵    var c2 animal
    jm := &dog{name:"金毛"}   //现animal接口的是*dog类型,所以必须要通过&来取值
    c2 = jm
    c2.move()   //金毛会动
    c2.speak()  //金毛会叫汪汪汪
}
Nach dem Login kopieren

Das obige ist der detaillierte Inhalt vonEinführung in die Golang-Schnittstelle. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Verwandte Etiketten:
Quelle:cnblogs.com
Erklärung dieser Website
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
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage