golang interface

接口定义

Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能 包含任何变量。

type Interface interface {
　　test1(a, b int) bool
　　test2()
}

interface类型默认是一个指针。

空接口（a interface{}）可以被任何类型所实现，如动物可以被猫、狗、人等实现，反之人不一定能实现动物

func main() {
　　var a interface{}

　　var b int
　　a = b

　　fmt.Printf("%T\n", a)

　　var s string
　　a = s

　　fmt.Printf("%T", a)
}

接口只是一种规范，并没有实现，不能直接调用

type testInterface int

func (t testInterface) test1(a, b int) bool {
	return a < b
}

func (t testInterface) test2() {
	fmt.Println("test2")
}

func main() {
	var a Interface
	a.test2()
}

接口实现

Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，golang中没有implement 类似的关键字。

type testInterface int

func (t testInterface) test1(a, b int) bool {
　　return a < b
}

func (t testInterface) test2() {
　　fmt.Println("test2")
}

func main() {
　　var a testInterface
　　fmt.Printf("%T\n", a.test1(1, 2))
　　a.test2()
}

接口实现时需要实现规范内的所有方法，否则会报错

type Interface interface {
	test1(a, b int) bool
	test2()
}

type testInterface int

func (t testInterface) test1(a, b int) bool {
	return a < b
}

func main() {
	var test testInterface
	var i Interface

	i = test

	fmt.Println(test)

}

cannot use test (type testInterface) as type Interface in assignment:
testInterface does not implement Interface (missing test2 method)

如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个 接口。

type human interface { //人类
	get_country() //国家
}

type lang interface {
	speek() //语言
}

type chinesePeople struct { //中国人
	country string
}

func (c chinesePeople) get_country() {
	fmt.Println(c.country)
}

type japanese struct { //日本人
	country string
}

func (c japanese) get_country() {
	fmt.Println(c.country)
}

func (c japanese) speek() { //说的语言
	fmt.Println("ハロー")
}

func main() {

	var c = chinesePeople{
		country: "china",
	}

	var j = japanese{
		country: "japan",
	}
	var h human
	var langage lang

	h = c

	h.get_country()

	langage = j
	h = j
	h.get_country()
	langage.speek()
}

japanese结构体实现了两个接口

chinese结构体实现了country接口如果使用lang赋值会提示未实现该接口

cannot use c (type chinesePeople) as type lang in assignment:
chinesePeople does not implement lang (missing speek method)

接口嵌套

一个接口可以嵌套在另外的接口

package main

type human interface {
	run()
	eyes()
}

type info interface {
	country()
	sex()
}

type chinesePeople interface {
	human
	info
}

func main() {

}

类型断言

接口是一般类型，不知道具体类型，如果要转成具体类型

语法

目标类型 := x.(t)
目标类型,布尔值 := x.(t)

两者区别为，安全类型与不安全类断言，非安全类型如果判定失败，这个操作会抛出panic

如：

var i interface{}
i = 10
j := i.(string)
fmt.Printf("%T\n", j)

断言的操作对象x是一个nil接口值，那么不论被断言的类型T是什么这个类型断言都会失败。

var i interface{}
i = nil
j := i.(nil)

安全类型的断言

t, ok := i.(int)
if ok == false {
　　fmt.Printf("失败,断言的类型为%T，而i的类型为%T", t, i)
　　os.Exit(1)
}

fmt.Printf("成功%T", t)