// Sayer 接口typeSayerinterface {say()}typedogstruct {}typecatstruct {}// dog实现了Sayer接口func (d dog) say() { fmt.Println("汪汪汪")}// cat实现了Sayer接口func (c cat) say() { fmt.Println("喵喵喵")}funcmain() {var x Sayer// 声明一个Sayer类型的变量x a :=cat{} // 实例化一个cat b :=dog{} // 实例化一个dog x = a // 可以把cat实例直接赋值给x x.say() // 喵喵喵 x = b // 可以把dog实例直接赋值给x x.say() // 汪汪汪}
值接收者和指针接收者实现接口的区别
func main() {
var x Sayer
var wangcai = dog{} // 旺财是dog类型
x = wangcai // x可以接收dog类型
var fugui = &dog{} // 富贵是*dog类型
x = fugui // x也可以接收*dog类型
x.say()
}
// Sayer 接口
type Sayer interface {
say()
}
// Mover 接口
type Mover interface {
move()
}
dog既可以实现Sayer接口，也可以实现Mover接口。
type dog struct {
name string
}
// 实现Sayer接口
func (d dog) say() {
fmt.Printf("%s会叫汪汪汪\n", d.name)
}
// 实现Mover接口
func (d dog) move() {
fmt.Printf("%s会动\n", d.name)
}
func main() {
var x Sayer
var y Mover
var a = dog{name: "旺财"}
x = a
y = a
x.say()
y.move()
}
多个类型实现同一接口
Go语言中不同的类型还可以实现同一接口 首先定义一个Mover接口，它要求必须由一个move方法。
// Mover 接口
type Mover interface {
move()
}
例如狗可以动，汽车也可以动，可以使用如下代码实现这个关系：
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)
}
// Sayer 接口
type Sayer interface {
say()
}
// Mover 接口
type Mover interface {
move()
}
// 接口嵌套
type animal interface {
Sayer
Mover
}
嵌套得到的接口的使用与普通接口一样，下面让cat实现animal接口：
type cat struct {
name string
}
func (c cat) say() {
fmt.Println("喵喵喵")
}
func (c cat) move() {
fmt.Println("猫会动")
}
func main() {
var x animal
x = cat{name: "花花"}
x.move()
x.say()
}
空接口
空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口。
空接口类型的变量可以存储任意类型的变量。
func main() {
// 定义一个空接口x
var x interface{}
s := "Hello 沙河"
x = s
fmt.Printf("type:%T value:%v\n", x, x)
i := 100
x = i
fmt.Printf("type:%T value:%v\n", x, x)
b := true
x = b
fmt.Printf("type:%T value:%v\n", x, x)
}
空接口可以作为函数的参数
使用空接口实现可以接收任意类型的函数参数。
// 空接口作为函数参数
func show(a interface{}) {
fmt.Printf("type:%T value:%v\n", a, a)
}
type uncommontype struct {
pkgpath nameOff
mcount uint16 // number of methods
xcount uint16 // number of exported methods
moff uint32 // offset from this uncommontype to [mcount]method
_ uint32 // unused
}
type eface struct {
_type *_type // 具体类型(concrete type),即上文中的类型元数据
data unsafe.Pointer // 具体类型的值
}
type iface struct {
tab *itab
data unsafe.Pointer
}
itab
type itab struct {
inter *interfacetype
_type *_type
link *itab
bad int32
inhash int32
fun [1]uintptr // 存的是接口函数的具体实现
}
// interfacetype 存储 interface 本身的信息
type interfacetype struct {
typ _type
pkgpath name
mhdr []imethod
}
//imethod 存储的只是函数声明，比如 func Print() error
type imethod struct {
name nameOff
ityp typeOff
}
func main() {
var x interface{}
x = "Hello 沙河"
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！")
}
}