接口
在Go语言中接口是一种类型，只要实现了这个接口方法的
就属于这个类型
在JAVA中
定义一个鸭子接口
那什么是鸭子？
鸭子是会嘎嘎嘎叫的
鸭子可以在水里游
等等。。。
那反过来
如果不能嘎嘎嘎叫，不能在水里游就不是鸭子
在go语言中没有那么多要求
只要你长得鸭子
那就你可以实现我这个接口
不管这个鸭子会不会叫
或者是玩具鸭子
只要实现了我这个接口方法
就是个鸭子
定义一个接口
定义一个鸭子类型的接口
只要实现了swim()方法
就是ducker类型
type ducker interface {
swim()
}
接口实现
package main
import "fmt"
func main() {
//定义一个ducker 变量
var d ducker
//定义一个toyboy的结构体
var t = toyDuck{price:32.2}
//因为 tiyduck变量实现了 swim方法
//我们说了 只要实现了接口的全部方法
//那么就可以是接口这个类型
d = t
fmt.Printf("type :%T\n",d)
//使用 ducker类型调用 swim方法
d.swim()
//输出
// type :main.toyDuck
// 这个价值32.20的玩具鸭在水上浮起来了
}
type ducker interface {
swim()
}
type toyDuck struct {
price float64
}
func ( t toyDuck) swim(){
//小数点后取两位输出
fmt.Printf("这个价值%0.2f的玩具鸭在水上浮起来了\n",t.price)
}
接口应用场景 (一个接口多个实现)
实现一个不管是什么车都可以跑的接口
首先定义一个车的接口类型
type carer interface{
run()
}
定义一个函数 不管传过来什么都可以调用run方法
这里参数 就是carer 类型
只要实现了run方法都是carer类型
所以可以调用carer.run()
func drive(x carer) {
x.run()
}
完整代码
package main
import "fmt"
//不管是什么牌子的车都能跑
func main() {
b1 := bmw{model: "745"}
b2 := benz{model: "G500"}
drive(b1)
drive(b2)
}
//接口等于定义 通用变量 （实现此方法的）
type carer interface {
run()
}
func drive(x carer) {
x.run()
}
type benz struct {
model string
}
type bmw struct {
model string
}
func (b benz) run() {
fmt.Printf("奔驰%s咻的走了\n", b.model)
}
func (b bmw) run() {
fmt.Printf("宝马%s嗖的走了\n", b.model)
}
接口多实现
一个结构体 也可以实现多个接口
可以是多个接口的类型
例如 玩具鸭 既是玩具 也是鸭子
package main
import "fmt"
func main() {
var td = toyDuck{price:32.8}
var d ducker = td
var t toyer = td
d.swim()
t.show()
}
type ducker interface {
swim()
}
type toyer interface {
show()
}
type toyDuck struct {
price float64
}
func ( t toyDuck) swim(){
//小数点后取两位输出
fmt.Printf("这个价值%0.2f的玩具鸭在水上浮起来了\n",t.price)
}
func ( t toyDuck) show(){
//小数点后取两位输出
fmt.Printf("这个价值%0.2f的玩具鸭在玻璃柜里展示着\n",t.price)
}
注意
只有实现了接口的全部方法 才是这个接口的类型
接口的实现方法多使用指针类型
package main
import "fmt"
func main() {
a := cat{
name: "小红",
feet: 4,
}
fmt.Println()
a.eat("草")
// 使用值接收者 和 指针接受者的区别
// 通常使用指针实现方法
// 值接收者 都可以存(指针变量和值变量)
// 指针接收者实现接口 只能存结构体指针类型的变量
var a1 animal
c2 := &cat{"假老练", 4}
fmt.Println(a1)
a1 = c2
fmt.Println(a1)
}
type animal interface {
speak()
eat(string) //带参数的接口
}
type cat struct {
name string
feet int8
}
type dog struct {
name string
feet int8
}
func (d dog) speak() {
fmt.Println("汪汪汪")
}
func (c *cat) speak() {
fmt.Println("喵喵喵")
}
func (d dog) eat(food string) {
fmt.Printf("%s 吃 %s \n", d.name, food)
}
func (c *cat) eat(food string) {
fmt.Printf("%s 吃 %s \n", c.name, food)
}
空接口
所有的类型都实现了空接口
任意类型都可以接收
相当于java object的参数
func show(i interface{}) {
fmt.Printf("type:%T value:%v\n", i, i)
}
