墨滴

猿码记

V1

2023/02/02阅读：27主题：橙心

Go学习(十四):面向对象-接口(interface)

虽然Go语言没有继承和多态，但是Go语言可以通过匿名字段实现继承，通过接口实现多态。

1.介绍

1.1 概念

在Go语言中，接口是一组方法签名。接口指定了类型应该具有的方法，类型决定了如何实现这些方法。当某个类型为接口中的所有方法提供了具体的实现细节时，这个类型就被称为实现了该接口。接口定义了一组方法，如果某个对象实现了该接口的所有方法，则此对象就实现了该接口。

1.2 声明语法

type 接口名称 interface {
    Method1([参数列表]) [返回值列表]
    Method2([参数列表]) [返回值列表]
    ...
}

示例

// 定义一个接口
type Bird interface {
 fly() // 无参数无返回值方法
 eat(string2 string) // 有参数无返回值方法
 walk(string2 string) string // 有参数有返回值方法
}

2.定义和实现

2.1 定义接口

// 定义一个鸟类接口
type Birder interface {
 fly()  
 eat(food string)
}

2.2 实现接口

Go没有implements或extends关键字,类型都是隐式实现接口的。任何定义了接口中所有方法的类型都被称为隐式地实现了该接口。

package main
import "fmt"
// 定义一个鸟类接口
type Birder interface {
 fly()
 eat(food string)
}
// 定义乌鸦结构体
type Crow struct {
 name string
}
// -------- 下面开始实现Bird接口 ------
func (c Crow) fly() {
 fmt.Printf("我是 %s,我会飞....\n", c.name)
}
func (c Crow) eat(food string) {
 fmt.Printf("我是 %s,我喜欢吃 %s \n", c.name,food)
}
// -------- 实现鸟类接口的所有方法，就代表实现了接口 ------
func main() {
 crow := Crow{"乌鸦"}
 crow.fly()
 crow.eat("谷子")
}
/** 输出
  我是 乌鸦,我会飞....
  我是 乌鸦,我喜欢吃 谷子 
*/

3. 模拟多态

3.1 什么是多态?

如果有几个相似而不完全相同的对象，有时人们要求在向它们发出同一个消息时，它们的反应各不相同，分别执行不同的操作，这种情况就是多态现象。Go语言中的多态性是在接口的帮助下实现的——定义接口类型，创建实现该接口的结构体对象。

3.2 使用示例

定义接口类型的对象，可以保存实现该接口的任何类型的值。Go语言接口变量的这个特性实现了Go语言中的多态性。

实现: 写一个函数，接收不同类型的结构体，并打印不同其方法。

package main
import "fmt"
// 定义一个飞行器接口
type Flying interface {
 getName() string
}
// 定义小鸟结构体
type bird struct {
  name string
}
// bird实现接口
func (b bird) getName() string {
 return b.name
}
// 定义飞机结构体
type aircraft struct {
 name string
}
// aircraft实现接口
func (a aircraft) getName() string {
 return a.name
}
// 定义ufo结构体
type ufo struct {
 name string
}
// ufo实现接口
func (u ufo) getName() string {
 return u.name
}
// 写一个函数，接收不同类型的结构体，并打印不同其方法。
func print(flyList []Flying)  {
 for _,v := range flyList {
  fmt.Printf("我是%s,我会飞.....\n",v.getName())
 }
}
func main() {
 // 定义一个接口切片
 flyList := make([]Flying,0,3)
 bird := bird{"小鸟"}
 aircraft := aircraft{"飞机"}
 ufo := ufo{"UFO"}
 flyList = append(flyList, bird,aircraft,ufo)
 fmt.Printf("len: %d cap:%d val: %v \n",len(flyList),cap(flyList),flyList)
 // 调用函数
 print(flyList)
}
/** 输出
  len: 3 cap:3 val: [{小鸟} {飞机} {UFO}] 
  我是小鸟,我会飞.....
  我是飞机,我会飞.....
  我是UFO,我会飞.....
*/

4.空接口

空接口是接口类型的特殊形式，空接口没有任何方法，因此任何类型都无须实现空接口。从实现的角度看，任何值都满足这个接口的需求。因此空接口类型可以保存任何值，也可以从空接口中取出原值。

4.1 定义空接口

// 定义一个空接口
type A interface {}

4.2 保存任意类型

package main
import "fmt"
// 定义一个空接口
type A interface {
}
func main() {
 // 声明变量
 var a A
 // 保存整型
 a = 10
 fmt.Printf("保存整型: %v \n", a)
 // 保存字符串
 a = "hello word"
 fmt.Printf("保存字符串: %v \n", a)
 // 保存数组
 a = [3]float32{1.0, 2.0, 3.0}
 fmt.Printf("保存数组: %v \n", a)
 // 保存切片
 a = []string{"您", "好"}
 fmt.Printf("保存切片: %v \n", a)
 // 保存Map
 a = map[string]int{
  "张三": 22,
  "李四": 25,
 }
 fmt.Printf("保存map: %v \n", a)
 // 保存结构体
 a = struct {
  name string
  age  int
 }{"王麻子", 40}
 fmt.Printf("保存结构体: %v \n", a)

 // 声明一个空接口切片
 var aa []A
 // 保存任意类型数据到切片中
 aa = append(aa, 23, []string{"php", "go"}, map[string]int{"a": 1, "b": 2}, struct {
  city,province string

 }{"合肥","安徽"})
 fmt.Printf("空接口切片: %v \n", aa)
}

/** 输出:
  保存整型: 10 
  保存字符串: hello word 
  保存数组: [1 2 3] 
  保存切片: [您 好] 
  保存map: map[张三:22 李四:25] 
  保存结构体: {王麻子 40} 
  空接口切片: [23 [php go] map[a:1 b:2] {合肥 安徽}] 
*/

4.3 从空接口中取值

保存到空接口的值，如果直接取出指定类型的值时，会发生编译错误。

错误示例:

package main
import "fmt"
// 定义一个空接口
type I interface {
}

func main() {
 // 声明变量num
 num := 10
 // 把变量num存到空接口中
 var i I = num
 fmt.Printf("输出变量i: %v \n", i)
  // 从空接口中取出值，赋值给新的变量 
 var c int = i // (!!! 这里会报错)
 fmt.Printf("输出变量c: %v \n", c)
}
/** 输出
 ./main.go:16:6: cannot use i (type I) as type int in assignment: need type assertion
*/

正确示例:

package main
import "fmt"
// 定义一个空接口
type I interface {
}
func main() {
 // 声明变量num
 num := 10
 // 把变量num存到空接口中
 var i I = num
 fmt.Printf("输出变量i: %v \n", i)
 // 从空接口中取出值，赋值给新的变量
 var c int = i.(int)
 fmt.Printf("输出变量c: %v \n", c)
}
/**
  输出变量i: 10 
  输出变量c: 10 
*/

5. 接口对象转换

5.1 转换语法

// 方式一
instance,ok := 接口对象.(实际类型)
// 方式二
接口对象.(实际类型)

5.2 使用示例

package main
import "fmt"
// 定义一个空接口
type I interface {
}

func main() {
 // 声明变量
 var a I
 // 保存整型
 a = 10
 printType(a)
 printType2(a)
 // 保存字符串
 a = "hello word"
 printType(a)
 printType2(a)
 // 保存数组
 a = [3]float32{1.0, 2.0, 3.0}
 printType(a)
 printType2(a)
 // 保存切片
 a = []string{"您", "好"}
 printType(a)
 printType2(a)
 // 保存Map
 a = map[string]string{
  "张三": "男",
  "小丽": "女",
 }
 printType(a)
 printType2(a)
 // 保存结构体
 a = people{"刘山", 32}
 printType(a)
 printType2(a)
}
// 定义结构体
type people struct {
 name string
 age  int
}

// 方式一
func printType(i I) {
 if t, ok := i.(int); ok {
  echo(t)
 } else if t, ok := i.(string); ok {
  echo(t)
 } else if t, ok := i.(map[string]string); ok {
  echo(t)
 } else if t, ok := i.([]int); ok {
  echo(t)
 } else if t, ok := i.([3]string); ok {
  echo(t)
 } else if t, ok := i.(people); ok {
  echo(t)
 }
}

// 方式二
func printType2(i I) {
 switch i.(type) {
 case int:
  echo2(i)
 case string:
  echo2(i)
 case map[string]string:
  echo2(i)
 case []int:
  echo2(i)
 case [3]string:
  echo2(i)
 case people:
  echo2(i)
 }
}
func echo(i interface{}) {
 fmt.Printf("方式一 ---> 变量i类型: %T 值: %v \n", i, i)
}
func echo2(i interface{}) {
 fmt.Printf("方式二 ---> 变量i类型: %T 值: %v \n", i, i)
}
/**输出
方式一 ---> 变量i类型: int 值: 10 
方式二 ---> 变量i类型: int 值: 10 
方式一 ---> 变量i类型: string 值: hello word 
方式二 ---> 变量i类型: string 值: hello word 
方式一 ---> 变量i类型: map[string]string 值: map[小丽:女 张三:男] 
方式二 ---> 变量i类型: map[string]string 值: map[小丽:女 张三:男] 
方式一 ---> 变量i类型: main.people 值: {刘山 32} 
方式二 ---> 变量i类型: main.people 值: {刘山 32} 
*/

6. 使用注意事项

  • 接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量(实例)
  • 接口中所有的方法都没有方法体,即都是没有实现的方法。
  • 在Go中，一个自定义类型需要将某个接口的所有方法都实现，我们说这个自定义类型实现 了该接口。
  • 一个自定义类型只有实现了某个接口，才能将该自定义类型的实例(变量)赋给接口类型
  • 只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型
  • 一个自定义类型可以实现多个接口
  • Go接口中不能有任何变量
  • interface类型默认是一个指针(引用类型)，如果没有对interface初始化就使用，那么会输出nil
  • 空接口 interface{} 没有任何方法，所以所有类型都实现了空接口, 即我们可以把任何一个变量 赋给空接口

分类：

后端

标签：

Golang

作者介绍

猿码记
V1