ToB企服应用市场:ToB评测及商务社交产业平台

标题: go基础-接口 [打印本页]
作者: 商道如狼道    时间: 2023-8-3 15:16
标题: go基础-接口
一、概述

接口是面向对象编程的重要概念，接口是对行为的抽象和概括，在主流面向对象语言Java、C++，接口和类之间有明确关系，称为“实现接口”。这种关系一般会以“类派生图”的方式进行，经常可以看到大型软件极为复杂的派生树，随着系统的功能不断增加，这棵“派生树”会变得越来越复杂。
Go语言接口模型非常特别，就目前观察是独创。go接口设计是非侵入式，只要类型方法是接口方法的超集，那么就认为类型实现了接口，两者之间不需要显示关联，当然也没有implements关键字，称为隐式实现。相比Java、C++主流面向对象语言需要显示实现接口，go的方式更加灵活、松散、耦合更低，当然也更加隐晦、代码可读性降低（当然有人不同意这种看法）。在不修改类型定义情况下，可以为其添加接口，这在Java、C++下是不可思议的。go的接口满足鸭子模型，所谓鸭子类型：只要走起路来像鸭子、叫起来也像鸭子，那么就可以把它当作鸭子。
 

二、基本使用

接口定义，描述一堆方法的集合，给出方法声明即可，不能有默认实现，也不能有变量
  1. type User interface {
  2.     Say()
  3.     GetName() string
  4. }
复制代码
定了一个user接口，包含两个方法
 
任何类型都可以实现这两个方法，不需要显示使用implements关键字。满足两个条件，与接口方法签名完全一致，是接口方法的超集。即可判定类型实现了接口。
  1. type Sales struct {                    // 定义类型
  2.     name string
  3. }
  5. func (p *Sales) GetName() string {    // 接口方法一
  6.     return p.name
  7. }
  9. func (p *Sales) Say() {                // 接口方法二
  10.     fmt.Println("Hi, I'm", p.name)
  11. }
  13. func (p *Sales) peddle() {            
  14.     fmt.Printf("%s peddle", p.name)
  15. }
复制代码
Sales类型满足两个条件，可判断实现了User接口。从代码上看两者没有直接关联，这就是隐式实现。
 
按照上面的两个条件，Sales也实现了如下接口
  1. type Person interface {
  2.     GetName() string
  3. }
复制代码
可以看到非常松散，就是这么简洁。再次强调只要满足两个条件：与接口方法签名一致，是接口方法的超集，即可判定类型实现了接口。从类型自身角度看，完全不知道自己实现了哪些接口。
 
通过实例调用方法
  1. var sales Sales = Sales{name: "tom"}
  2. sales.Say()
复制代码
 
通过接口调用方法，只要类型实现了接口，就可以赋值给接口变量，并使用接口调用方法
  1. var user User = &Sales{name: "tom"}        // 赋值给接口变量，注意是地址
  2. user.Say()                                 // 通过接口调用方法
  4. fmt.Printf("%T\n", user)                　 // *main.Sales
复制代码
接口是引用类型，和指针一样，只能指向实例的地址。
 
接口主要目标是解耦，通常称为面向接口编程，主流使用方式是函数形参是接口类型，调用时候传递接口变量，这也是接口存在的意义。
  1. func PrintName(user User) {                    // 形参是User接口类型
  2.     fmt.Println("姓名:", user.GetName())
  3. }
  5. var sales User = &Sales{name: "tom"}        
  6. PrintName(sales)                            // 传入user接口变量
复制代码
形参是接口类型，可传入所有实现了该接口的实例，不在依赖具体类型。
 
在标准库中大量使用接口。比如排序是普片需求，标准库提供了排序函数，形参是接口类型，任何实现了该接口的类型，都可直接使用排序函数
  1. type Interface interface {        // 排序接口
  2.     Len() int
  3.     Less(i, j int) bool
  4.     Swap(i, j int)
  5. }
  7. func Sort(data Interface) {        // 标准库排序函数
  8.     ...
  9. }
复制代码
 
和结构体一样，接口也支持继承特性
  1. type User interface {
  2.     Say()
  3.     GetName() string
  4. }type Admin interface {    User                // 继承User接口    TeamName string        // 自有属性}
复制代码
需要实现包括继承的所有方法，才判定实现了该接口
 
并非只能使用结构体实现接口，其他自定义类型也可以实现接口，如下X类型实现了Plus接口
  1. type Plus interface {
  2.     incr()
  3. }
  5. type X int
  7. func (x *X) incr() {
  8.     *x += 1
  9.     fmt.Println(*x)
  10. }
复制代码
 
三、接口断言

在接口变量上操作，用于检查接口类型变量是否实现了期望的接口或者具体的类型。使用接口的本质，就是实例类型和接口类型之间转换，而是否允许转换就依赖断言
  1. value, ok := x.(T)
复制代码
x 表示接口的类型，T 表示具体类型（也可以是接口），可根据该布尔值判断 x 是否为 T 类型。
 
使用上面案例进行断言
  1. var user User = &Sales{name: "tony"}
  3. if value, ok := user.(User); ok {        // true,  接口断言
  4.     value.Say()   
  5. }
  7. _, ok = user.(*Sales)                    // true, 具体类型断言, 注意这里使用了指针类型
复制代码
 
注意，如果不接收第二个返回值（也就是 ok），断言失败时会 panic，对nil断言同样也会 panic。
  1. admin := user.(Admin)    // Admin是管理员接口，断言失败panic
复制代码
 
具体类型实例如何断言，可以先转为为接口，然后再进行断言
  1. user1 := Sales{"tom"}
  3. var data interface{} = user1      // 转换为空接口
  5. if _, ok := data.(Sales); ok {    // 再进行断言
  6.     fmt.Println("yes")
  7. }
复制代码
 
断言常见使用场景，异常捕获时判定错误类型
  1. func ProtectRun(entry func()) {
  2.     defer func() {
  3.         err := recover()            // 获取错误类型
  4.         
  5.         switch err.(type) {            // 断言错误类型, 不同类型的错误采取不同的处理方式
  6.         case runtime.Error:
  7.             fmt.Println("runtime error:", err)
  8.         default:
  9.             fmt.Println("error:", err)
  10.         }
  11.     }()
  13.     ...
  14. }
复制代码
 
四、接口转换

go语言基本数据类型转换比较严格，所有基础类型不支持隐式转换，如下案例都不支持
  1. s := "a" + 1　　　　// err
  3. // 不同长度的整型, 也支持自动转换
  4. var i int = 10
  5. var n int8 = 20
  6. m := i+n　　　　　　// err
复制代码
 
go只能显示转换
  1. s := "a" + string(1)    　　// a1
  3. var i int = 10
  4. var n int8 = 20
  5. m := i + int(n)            // 30
复制代码
 
使用接口的本质就是类型转换，赋值时转换为接口变量，执行时候转换为实例。 go 语言对于接口类型的转换则非常的灵活，对象和接口之间的转换、接口和接口之间的转换都可能是隐式的转换
  1. var f *os.File
  2. var a io.ReadCloser = f        // 隐式转换, *os.File 满足 io.ReadCloser 接口
  3. var b io.Reader = a             // 隐式转换, io.ReadCloser 满足 io.Reader 接口
  4. var c io.Closer = a             // 隐式转换, io.ReadCloser 满足 io.Closer 接口
  5. var d io.Reader = a.(io.Reader) // 显式转换, io.Closer 不满足 io.Reader 接口
复制代码
 
有时候对象和接口之间太灵活了，导致需要人为地限制这种无意之间的适配。常见的做法是定义一个含特殊方法来区分接口。比如 runtime 包中的 Error 接口就定义了一个特有的 RuntimeError 方法，用于避免其它类型无意中适配了该接口
  1. type runtime.Error interface {
  2.     error
  3.     RuntimeError()
  4. }
复制代码
 
不过这种做法只是君子协定，如果有人刻意伪造接口也是很容易的。再严格一点的做法是给接口定义一个私有方法。只有满足了这个私有方法的对象才可能满足这个接口，而私有方法的名字是包含包的绝对路径名的，因此只能在包内部实现这个私有方法才能满足这个接口。测试包中的 testing.TB 接口就是采用类似的技术
  1. type testing.TB interface {
  2.     Error(args ...interface{})
  3.     Errorf(format string, args ...interface{})
  4.     ...
  5.     private()　　// 私有方法
  6. }
复制代码
 
不过这种通过私有方法禁止外部对象实现接口的做法也是有代价的，首先是这个接口只能包内部使用，外部包正常情况下是无法直接创建满足该接口对象的；其次，这种防护措施也不是绝对的，恶意的用户依然可以绕过这种保护机制。通过嵌入匿名的 testing.TB 接口来伪造私有的 private 方法，因为接口方法是延迟绑定，编译时 private 方法是否真的存在并不重要。
  1. type TB struct {
  2.     testing.TB
  3. }
  5. func (p *TB) Fatal(args ...interface{}) {
  6.     fmt.Println("TB.Fatal disabled!")
  7. }
  9. func main() {
  10.     var tb testing.TB = new(TB)
  11.     tb.Fatal("Hello, playground")
  12. }
复制代码
在自己的 TB 结构体类型中重新实现了 Fatal 方法，然后通过将对象隐式转换为 testing.TB 接口类型（因为内嵌了匿名的 testing.TB 对象，因此是满足 testing.TB 接口的），然后通过 testing.TB 接口来调用我们自己的 Fatal 方法。
 
五、空接口

接口定义没有声明任何方法，称为空接口，按照go规范任何类型都实现了空接口，因为都满足了两个实现条件。这就比较有意思了，空接口可以等于任何值，类似Java中的Object对象。
  1. var data interface{}        // 定义空接口变量
  3. data = 1
  4. fmt.Printf("type=%T, value=%v\n", data, data)
  5. data = "hello"
  6. fmt.Printf("type=%T, value=%v\n", data, data
复制代码
输出如下
  1. type=int, value=1
  2. type=string, value=hello
复制代码
 
函数形参是空接口类型，就表示可接收任何类型，然后再在断言，不同的类型，采用不同的逻辑，在开发框架层时经常使用
  1. func assertion(T interface{}) {
  2.     switch T.(type) {
  3.     case User:
  4.         fmt.Println("user")
  5.     case Admin:
  6.         fmt.Println("admin")
  7.     default:
  8.         fmt.Println("default")
  9.     }
  10. }
复制代码
T.(type)语法只能在switch中使用，可以理解定制语法糖，否则需要使用if逐个类型断言
 
空接口在标准库空也有普遍使用，比如panic函数终止程序时，可传递空接口类型的参数，捕获错误时可获取
  1. type any = interface{}
  3. func panic(v any)
复制代码
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4