Bolehkah go language membangunkan antara muka?

Bahasa Go boleh membangunkan antara muka. Antara muka dalam bahasa Go ialah tandatangan satu set kaedah Ia adalah bahagian penting dalam bahasa Go Perkara yang dilakukan oleh antara muka adalah seperti mentakrifkan spesifikasi atau protokol. Kata kunci antara muka digunakan dalam bahasa go untuk mentakrifkan antara muka Sintaks ialah "jenis antara muka jenis antara muka{nama kaedah 1 (senarai parameter 1) senarai nilai pulangan 1 nama kaedah 2 (senarai parameter 2) senarai nilai pulangan 2.. .}".

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Antara muka sepatutnya menjadi konsep yang biasa bagi kami Ia digunakan secara meluas dalam pelbagai bahasa pembangunan Bagi pengaturcara seperti kami yang lebih mengenali Java, antara muka lebih biasa Di bawah Mari kita lihat bagaimana antara muka digunakan dalam bahasa Go dan peranan mereka dalam pembangunan harian.

Konsep

Antara muka dalam bahasa go ialah tanda tangan set kaedah Ia merupakan bahagian penting dalam bahasa go mendefinisikan sesuatu spesifikasi atau perjanjian, setiap pihak pelaksana hanya perlu melaksanakannya mengikut perjanjian.

Antara muka ialah jenis

Jenis antara muka ialah abstraksi dan generalisasi bagi gelagat jenis lain Ia tidak mengambil berat tentang butiran pelaksanaan khusus ini boleh menjadikan fungsi kami lebih fleksibel.

Takrifan antara muka

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

Dalam bahasa go kami menggunakan kata kunci antara muka untuk mentakrifkan antara muka.

Syarat pelaksanaan antara muka

Jika set kaedah mana-mana jenis T ialah superset set kaedah bagi jenis antara muka, maka kita katakan jenis T melaksanakan antara muka .

Pelaksanaan antara muka adalah tersirat dalam bahasa Go, yang bermaksud bahawa perhubungan pelaksanaan antara kedua-dua jenis tidak perlu ditunjukkan dalam kod tersebut Bahasa Go Go Pengkompil secara automatik akan menyemak hubungan pelaksanaan antara dua jenis apabila diperlukan. Selepas antara muka ditakrifkan, ia perlu dilaksanakan supaya pemanggil boleh menyusun dan menggunakan antara muka dengan betul.

Pelaksanaan antara muka perlu mengikut dua peraturan untuk menyediakan antara muka:

1 Kaedah antara muka mempunyai format yang sama dengan kaedah jenis yang melaksanakan antara muka kaedah yang konsisten dengan tandatangan antara muka dalam jenis. Tandatangan termasuk nama, senarai parameter dan senarai parameter pulangan kaedah. Dengan kata lain, selagi mana-mana nama, senarai parameter, dan senarai parameter pulangan kaedah dalam jenis antara muka yang dilaksanakan tidak konsisten dengan kaedah yang akan dilaksanakan oleh antara muka, maka kaedah antara muka ini tidak akan dilaksanakan.

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

Apabila jenis tidak dapat melaksanakan antara muka, pengkompil akan melaporkan ralat:

a. Ralat disebabkan oleh nama fungsi yang tidak konsisten

b tandatangan untuk melaksanakan fungsi Laporan ralat

2 Semua kaedah dalam antara muka dilaksanakan Apabila terdapat berbilang kaedah dalam antara muka, hanya jika kaedah ini dilaksanakan, antara muka boleh disusun dan digunakan dengan betul

.

func (h *Xiaomi) Call() {
	fmt.Printf("%s:可以打电话",h.Name)
}

func main() {
	h := new(Xiaomi)
	h.Name="小米"
	var phone Phone
	phone = h
	phone.SendMessage()
}

Apabila jenis Xiaomi hanya melaksanakan satu kaedah dalam antara muka, ralat kompilasi akan dilaporkan apabila kami menggunakannya.

Hubungan antara jenis dan antara muka

Satu jenis melaksanakan berbilang antara muka

Satu jenis boleh melaksanakan berbilang antara muka, dan antara muka adalah bebas antara satu sama lain dan tidak mengetahui pelaksanaannya antara satu sama lain.

Sebagai contoh, seekor anjing boleh bergerak dan menyalak

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

Berbilang jenis melaksanakan antara muka yang sama

Go Different jenis dalam bahasa juga boleh melaksanakan antara muka yang sama Mula-mula kita mentakrifkan antara muka Mover, yang memerlukan kaedah bergerak.

type Mover interface {
    move()
}

Sebagai contoh, anjing boleh bergerak dan kereta juga boleh bergerak Anda boleh menggunakan kod berikut untuk mencapai hubungan ini:

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

Pada masa ini, kami boleh merawat anjing. dan kereta sebagai satu dalam kod Objek bergerak diuruskan Anda tidak perlu lagi memberi perhatian kepada mereka.

func main() {
        var x Mover
        var a = dog{name: "旺财"}
        var b = car{brand: "保时捷"}
        x = a
        x.move()
        x = b
        x.move()
    }

Antara muka kosong

Antara muka kosong: antara muka{}, tidak mengandungi sebarang kaedah Kerana ini, sebarang jenis melaksanakan antara muka kosong, jadi kosong antara muka Sebarang jenis data boleh disimpan.

fmt Siri Print fungsi di bawah pakej, kebanyakan parameternya adalah jenis antara muka kosong, ia juga boleh dikatakan menyokong sebarang jenis

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)

Antara muka null sebagai nilai peta

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

Taip inferens

Antara muka kosong boleh menyimpan sebarang jenis nilai, jadi bagaimana kita mendapatkan data khusus yang disimpannya?

Nilai antara muka

Nilai antara muka (dirujuk sebagai nilai antara muka) terdiri daripada jenis tertentu dan nilai jenis tertentu.

Dua bahagian ini masing-masing dipanggil jenis dinamik dan nilai dinamik antara muka.

Jika anda ingin menentukan nilai dalam antara muka kosong, anda boleh menggunakan penegasan jenis Format sintaks ialah:

x.(T)

di mana:

• <.>x : Mewakili pembolehubah jenis antara muka{}

• T: Mewakili jenis penegasan x mungkin.

该语法返回两个参数，第一个参数是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视频教程、编程教学】

Atas ialah kandungan terperinci Bolehkah go language membangunkan antara muka?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!