Golang中的接口

目录

一、接口的介绍
二、Golang接口的定义
三、空接口
四、类型断言
五、结构体值接收者和指针接收者实现接口的区别
六、一个结构体实现多个接口
七、接口嵌套

一、接口的介绍

1. 现实生活中的接口

现实生活中，手机、相机、U盘都可以和电脑的USB接口建立连接。我们不需要关注USB卡槽大小是否一样，因为所有的USB接口都是按照统一的标准来设计的。

2. Golang中的接口（interface）

Golang中的接口是一种抽象数据类型，它定义了对象的行为规范，只定义规范，不实现。接口中定义的规范由具体的对象来实现。

通俗地说，接口就是一个标准，它约定实现接口的对象必须遵循接口的规范。

二、Golang接口的定义

在Golang中，接口（interface）是一种类型，一种抽象的类型。接口是一组方法（method）的集合，接口中不能包含任何变量。

• 接口中的所有方法都没有方法体
• 接口定义了对象的行为规范，只定义规范不实现
• 接口体现了多态和高内聚低耦合的思想
• 接口是一种数据类型，不需要显式实现。只要一个变量含有接口类型中的所有方法，该变量就实现了这个接口

接口的定义格式

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

命名规范：

• 接口名通常使用 type 定义为自定义类型名，一般会在单词后加 er，如 Writer、Stringer 等
• 方法名首字母大写时，可被包外的代码访问
• 参数列表和返回值列表中的参数变量名可以省略

定义接口并由结构体实现

package main

import "fmt"

// 定义 Usber 接口，是一个规范
type Usber interface {
    Start()
    Stop()
}

// Phone 结构体实现 Usber 接口
type Phone struct {
    Name string
}
func (p Phone) Start() {
    fmt.Println(p.Name, "开始工作")
}
func (p Phone) Stop() {
    fmt.Println(p.Name, "停止工作")
}

// Camera 结构体实现 Usber 接口
type Camera struct {
    Name string
}
func (c Camera) Start() {
    fmt.Println(c.Name, "开始工作")
}
func (c Camera) Stop() {
    fmt.Println(c.Name, "停止工作")
}

func main() {
    phone := Phone{Name: "小米手机"}
    // Phone实现Usber接口
    var p Usber = phone
    p.Start()
    p.Stop()

    camera := Camera{Name: "佳能相机"}
    // Camera实现Usber接口
    var c Usber = camera
    c.Start()
    c.Stop()
}

接口作为函数参数

package main

import "fmt"

type Usber interface {
    Start()
    Stop()
}

type Phone struct {
    Name string
}
func (p Phone) Start() {
    fmt.Println(p.Name, "开始工作")
}
func (p Phone) Stop() {
    fmt.Println(p.Name, "停止工作")
}

type Camera struct {
    Name string
}
func (c Camera) Start() {
    fmt.Println(c.Name, "开始工作")
}
func (c Camera) Stop() {
    fmt.Println(c.Name, "停止工作")
}

// Computer结构体的Work方法接收Usber接口类型的参数
type Computer struct{}
func (c Computer) Work(usb Usber) {
    usb.Start()
    usb.Stop()
}

func main() {
    computer := Computer{}

    phone := Phone{Name: "小米手机"}
    camera := Camera{Name: "佳能相机"}

    computer.Work(phone)
    computer.Work(camera)
}

三、空接口

Golang中的接口可以不定义任何方法，没有定义任何方法的接口就是空接口。

• 空接口表示没有任何约束
• 任何类型变量都可以实现空接口
• 空接口在实际项目中应用广泛，可表示任意数据类型

空接口表示接受任意类型

type A interface{} //空接口 表示没有任何约束 任意的类型都可以实现空接口

func main() {
    var x interface{} // 定义空接口

    s := "你好golang"
    x = s // 让字符串实现这个空接口
    fmt.Printf("type:%T value:%v\n", x, x)
    // string 你好golang

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

1. 空接口作为函数参数

表示函数参数表示可以接受任意类型。

func show(a interface{}) {
    fmt.Printf("type:%T value:%v\n", a, a)
}

show(20)
// 20 int

2. map 的值使用空接口

var studentInfo = make(map[string]interface{})
studentInfo["name"] = "张三"
studentInfo["age"] = 18
studentInfo["married"] = false
fmt.Println(studentInfo)

3. 切片使用空接口

var slice = []interface{}{"张三", 20, true, 32.2}
fmt.Println(slice)

四、类型断言

一个接口的值（简称接口值）由具体类型和具体类型的值两部分组成，分别称为接口的动态类型和动态值。

如果我们想要判断空接口中值的类型，那么这个时候就可以使用类型断言，其语法格式：

语法格式

x.(T)

• x：类型为 interface{} 的变量
• T：断言 x 可能的类型

返回值

• 第一个值：x 转换为 T 类型后的变量
• 第二个值：布尔值，true 表示断言成功，false 表示断言失败

1. 单次类型断言

func main() {
    var x interface{}
    x = "Hello golang"

    v, ok := x.(string)
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("类型断言失败")
    }
}

上面的示例中如果要断言多次就需要写多个if判断，这个时候我们可以使用switch语句来判断：

2. 使用 switch 进行类型断言

注意：类型.(type) 只能结合 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 an int, value is %v\n", v)
    case bool:
        fmt.Printf("x is a bool, value is %v\n", v)
    default:
        fmt.Println("unsupported type!")
    }
}

3. 类型断言在非空接口中的使用

func (c Computer) work(usb Usber) {
    // 要判断usb的类型
    if _, ok := usb.(Phone); ok { //类型断言
        usb.start()
    } else {
        usb.stop()
    }
}

建议：只有当两个或两个以上的具体类型必须以相同方式处理时，才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象和运行时损耗。

空接口和类型断言使用细节

package main
import "fmt"

type Address struct {
    Name string
    Phone int
}

func main() {
    var userinfo = make(map[string]interface{})
    userinfo["username"] = "张三"
    userinfo["age"] = 20
    userinfo["hobby"] = []string{"睡觉", "吃饭"} // 将切片赋值给空接口类型的对象
    fmt.Println(userinfo["age"]) // 20
    fmt.Println(userinfo["hobby"]) // 有值
    fmt.Println(userinfo["hobby"][1]) // 报错：interface {} does not support indexing
    // 1. 空接口类型不支持通过索引获取

    var address = Address{
    Name: "李四",
    Phone: 1521242141,
    }

    fmt.Println(address.Name) //李四
    userinfo["address"] = address // 将结构体赋值给空接口类型的对象
    fmt.Println(userinfo["address"]) //{李四 1521242141}
    fmt.Println(userinfo["address"].Name) // 报错：type interface {} is interface with no methods
    // 2. 空接口的值没有Name这个方法

    // 使用类型断言解决上面问题：
    hobby2, _ := userinfo["hobby"].([]string)
    fmt.Println(hobby2[1]) // 吃饭
    address2, _ := userinfo["address"].(Address)
    fmt.Println(address2.Name, address2.Phone) // 李四 1521242141
}

五、结构体值接收者和指针接收者实现接口的区别

值接收者

如果结构体中的方法是值接收者，那么结构体值类型和结构体指针类型都可以赋值给接口变量。

package main
import "fmt"

type Usb interface {
    Start()
    Stop()
}

type Phone struct {
    Name string
}
// 值接收者
func (p Phone) Start() {
    fmt.Println(p.Name, "开始工作")
}
func (p Phone) Stop() {
    fmt.Println("phone 停止")
}

func main() {
    // 值类型可以赋值给接口
    phone1 := Phone{Name: "小米手机"}
    var p1 Usb = phone1 // 让phone1实现Usb接口
    p1.Start() // 小米手机 开始工作

    // 指针类型也可以赋值给接口
    phone2 := &Phone{Name: "苹果手机"}
    var p2 Usb = phone2 // 让phone2实现Usb接口
    p2.Start() // 苹果手机 开始工作
}

指针接收者

如果结构体中的方法是指针接收者，那么只有结构体指针类型可以赋值给接口变量，结构体值类型不能赋值给接口变量。

package main
import "fmt"

type Usb interface {
    Start()
    Stop()
}

type Phone struct {
    Name string
}
// 指针接收者
func (p *Phone) Start() {
    fmt.Println(p.Name, "开始工作")
}
func (p *Phone) Stop() {
    fmt.Println("phone 停止")
}

func main() {
    // 错误写法：值类型不能赋值给接口
    /*
    phone1 := Phone{Name: "小米手机"}
    var p1 Usb = phone1  // 编译错误
    p1.Start()
    */

    // 正确写法：指针类型可以赋值给接口
    phone2 := &Phone{Name: "苹果手机"}
    var p2 Usb = phone2
    p2.Start()
}

接口的方法中有参数或返回值

定义一个Animal的接口，Animal中定义两个方法，分别是SetName和GetName。分别让Dog结构体和Cat结构体实现这个方法。

package main
import "fmt"

type Animaler interface {
    SetName(string)
    GetName() string
}

type Dog struct {
    Name string
}
// 修改值必须用*Dog
func (d *Dog) SetName(name string) {
    d.Name = name
}
func (d Dog) GetName() string {
    return d.Name
}

type Cat struct {
    Name string
}
func (c *Cat) SetName(name string) {
    c.Name = name
}
func (c Cat) GetName() string {
    return c.Name
}

func main() {
    // Dog实现Animal的接口
    // 因为Dog结构体中有指针类型的接收者，所以必须&Dog
    d := &Dog{
        Name: "小黑",
    }
    var d1 Animaler = d // 实现Animaler接口
    fmt.Println(d1.GetName()) // 小黑
    d1.SetName("阿奇")
    fmt.Println(d1.GetName()) // 阿奇

    // Cat实现Animal的接口
    c := &Cat{
        Name: "小花",
    }
    var c1 Animaler = c // 实现Animaler接口
    fmt.Println(c1.GetName()) // 小花
}

六、一个结构体实现多个接口

Golang中一个结构体可以实现多个接口。

package main
import "fmt"

type AInterface interface {
    GetInfo() string
}

type BInterface interface {
    SetInfo(name string, age int)
}

type People struct {
    Name string
    Age  int
}
func (p People) GetInfo() string {
    return fmt.Sprintf("姓名:%v 年龄:%d", p.Name, p.Age)
}
func (p *People) SetInfo(name string, age int) {
    p.Name = name
    p.Age = age
}

func main() {
    people := &People{
        Name: "张三",
        Age:  20,
    }

    // people 同时实现了 AInterface 和 BInterface
    var p1 AInterface = people
    var p2 BInterface = people

    fmt.Println(p1.GetInfo()) // 张三 20
    p2.SetInfo("李四", 30)
    fmt.Println(p1.GetInfo()) // 李四 30
}

七、接口嵌套

接口与接口之间可以通过嵌套创建新的接口。

package main
import "fmt"

type SayInterface interface {
    say()
}

type MoveInterface interface {
    move()
}

// 接口嵌套
type Animal interface {
    SayInterface
    MoveInterface
}

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