Go语言接口与多态详细介绍_Golang

接口与多态

1. 接口

1. 接口的定义

1、go语言提供了接口数据类型。
2、接口就是把一些共性的方法集合在一起定义。
3、如果有实现类将接口定义的方法全部实现了，那么就代表实现了这个接口
4、隐式实现 go ，假设a实现了b接口中的所有方法，不需要显示声明
5、接口是方法的定义集合，不需要实现具体的方法内容。名字约束

在go语言中，接口（interface）是一个重要的特性，它允许我们定义一组方法但不实现它们，任何类型只要实现了这些方法，就被认为是实现了该接口。
接口体现了程序设计的多态、高内聚、低耦合的思想，是实现面向对象编程中多态性的关键工具。

接口通过interface关键字定义，它是一组方法的集合。接口中的方法没有实现体，即它们没有具体的实现代码。一个类型只要实现了接口中的所有方法，就认为该类型实现了该接口。
如果一个结构体实现了这个接口所有的方法，那这个结构体就是这个接口类型的

2. 接口应用代码示例

接口的基本语法如下：

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

package main
import (
    "fmt"
)
// 接口： usb、typec、插座
// 1、go语言提供了接口数据类型。
// 2、接口就是把一些共性的方法集合在一起定义。
// 3、如果有实现类将接口定义的方法全部实现了，那么就代表实现了这个接口
// 4、隐式实现 go ，假设a实现了b接口中的所有方法，不需要显示声明
// 5、接口是方法的定义集合，不需要实现具体的方法内容。名字约束
// usb 接口的定义 interface 来定义，方法太多了，要归类，方法的集合
type usb interface { // 接口，方法的集合
    input()  // 输入方法
    output() // 输出方法
}
// mouse 结构体
type mouse struct {
    name string
}
// 结构体实现了接口的全部方法就代表实现了这个接口，否则不算实现这个接口
func (mouse mouse) output() {
    fmt.println(mouse.name, "鼠标输出")
}
func (mouse mouse) input() {
    fmt.println(mouse.name, "鼠标输入")
}
// 接口调用测试
func test(u usb) {
    u.input()
    u.output()
}
func main() {
    // 通过传入接口实现类来进行调用
    m1 := mouse{name: "罗技"}
    // test 参数 usb 类型，如果一个结构体实现了这个接口所有的方法，那这个结构体就是这个接口类型的
    test(m1)
    //也可以单独测试接口
    //m1.input()
    k1 := keyboard{name: "雷蛇"}
    test(k1)
    // 定义高级类型  k1就升级了  keyboard --> usb  向上转型
    var usb usb
    usb = k1
    fmt.println(usb)
    // 接口是无法使用实现类的属性的
    //fmt.println(usb.name)
}
// keyboard 结构体
type keyboard struct {
    name string
}
// 结构体实现了接口的全部方法就代表实现了这个接口，否则不算实现这个接口
func (key keyboard) output() {
    fmt.println(key.name, "键盘输出")
}
func (key keyboard) input() {
    fmt.println(key.name, "键盘输入")
}

带有参数和返回值的接口

package main
import "fmt"
// tongxin 定义接口
type tongxin interface {
    //定义带有参数和返回值的方法
    dadianhua(youdian bool) string
    jieidanhua(youdian bool) string
}
// people 定义结构体
type people struct {
    name  string
    age   int
    phone string
}
// 实现接口
func (p people) dadianhua(youdian bool) string {
    if youdian {
        return fmt.sprintf("%v 打了电话", p.name)
    } else {
        return fmt.sprintf("打电话时手机没电了")
    }
}
func (p people) jieidanhua(youdian bool) string {
    if youdian {
        return fmt.sprintf("%v 接了电话", p.name)
    } else {
        return fmt.sprintf("接电话时手机没电了")
    }
}
// 接口测试，有传参，有返回值
func testdianhua(phone tongxin) {
    str1 := phone.dadianhua(false)
    str2 := phone.jieidanhua(true)
    fmt.println(str1, str2)
}
func main() {
    //创建对象
    p := people{"jingtian", 18, "18898985898"}
    //如果一个结构体实现了这个接口所有的方法，那这个结构体就是这个接口类型的
    testdianhua(p)
}

2. 模拟多态

多态是指相同的接口（方法）可以表现出不同的行为。在go语言中，通过接口实现多态。
在go语言中，接口定义了一组方法的集合，但不实现它们，而是由具体的类型来实现这些方法。
任何实现了接口中所有方法的类型都被视为该接口的实现。接口是go语言中实现多态性的关键。

多态：一个事务有多种形态
父类：动物
子类：猫
子类：狗

猫和狗是多态的，他们既可以是自己，也可以是动物，这个就是多态，一个事务有多种形态

go语言中多态的实现
定义接口
首先，我们需要定义一个接口，该接口包含了一组需要被实现的方法。例如，我们可以定义一个shape接口，用于计算不同形状的面积。

type shape interface {  
    area() float64  
}

在这个接口中，我们定义了一个area()方法，该方法返回一个float64类型的值，表示形状的面积。

实现接口
接下来，我们需要定义具体的类型来实现这个接口。这些类型将提供area()方法的具体实现。
矩形

type rectangle struct {  
    width  float64  
    height float64  
}  
func (r rectangle) area() float64 {  
    return r.width * r.height  
}

圆形

type circle struct {  
    radius float64  
}  
func (c circle) area() float64 {  
    return math.pi * c.radius * c.radius  
}

使用接口进行多态调用
现在，我们可以使用shape接口来创建不同类型的形状对象，并通过接口进行多态调用。

func main() {  
    r := rectangle{width: 4, height: 5}  
    c := circle{radius: 3}  
    shapes := []shape{r, c}  
    for _, shape := range shapes {  
        fmt.printf("area: %f\n", shape.area())  
    }  
}

完整代码

package main
import (
    "fmt"
    "math"
)
type shape interface {
    area() float64
}
// rectangle 矩形
type rectangle struct {
    width  float64
    height float64
}
func (r rectangle) area() float64 {
    return r.width * r.height
}
// circle 圆形
type circle struct {
    radius float64
}
func (c circle) area() float64 {
    return math.pi * c.radius * c.radius
}
func main() {
    r := rectangle{width: 4, height: 5}
    c := circle{radius: 3}
    shapes := []shape{r, c}
    for _, shape := range shapes {
        fmt.printf("area: %f\n", shape.area())
    }
}

在上面的代码中，我们创建了一个shapes切片，该切片包含了不同类型的形状对象（矩形和圆形）。
然后，我们遍历shapes切片，并通过shape接口调用area()方法。由于这两种形状都实现了shape接口，因此多态性使我们能够以一致的方式调用它们的area()方法。

多态案例2：

package main
import "fmt"
// animal3 定义接口
type animal3 interface {
    eat()
    sleep()
}
type dog3 struct {
    name string
}
func (dog dog3) eat() {
    fmt.println(dog.name, "--eat")
}
func (dog dog3) sleep() {
    fmt.println(dog.name, "--sleep")
}
// 多态
func main() {
    // dog 两重身份：1、dog   2、animal ，多态
    dog1 := dog3{name: "旺财"}
    dog1.eat()
    dog1.sleep()
    // dog 也可以是 animal
    test2(dog1)
    // 定义一个类型可以为接口类型的变量
    // 实际上所有实现类都可以赋值给这个对象
    var animal animal3 // 模糊的 -- 具体化，将具体的实现类赋值给他，才有意义
    animal = dog1
    //接口是无法使用实现类的属性的
    test2(animal)
}
// animal 接口
func test2(a animal3) {
    a.eat()
    a.sleep()
}

接口的实现类都拥有多态特性：除了自己本身还是他对应接口的类型。

3. 空接口

空接口interface{}不包含任何方法，因此任何类型都实现了空接口。空接口可以被视为能装入任意数量、任意数据类型的数据容器。
因此空接口可以存储任何的类型
空接口不好记，因此在新版本go中起了个名字，叫any

interface{}  == any

之所以我们的fmt.println能打印所有东西，就是因为它传入的参数就是any，而any的类型就是空接口

点击any进去看看，就是空接口

package main
import "fmt"
// a 定义空接口
type a interface{}
// dogg 所有结构体都实现了空接口a
type dogg struct {
    name string
}
type catt struct {
    name string
}
func testnow(a a) {
    fmt.println(a)
}
// 可以指定定义空接口
// // any is an alias for interface{} and is equivalent to interface{} in all ways.
// type any = interface{}
// 可以传入任何东西
func testnow2(temp interface{}) {
}
func main() {
    //a类型可以是任何类型
    var a1 a = catt{name: "喵喵"}
    var a2 a = dogg{name: "旺财"}
    var a3 a = 1
    var a4 a = "景天科技苑"
    fmt.println(a1)
    fmt.println(a2)
    fmt.println(a3)
    fmt.println(a4)
    testnow(a1)
    // map结合空接口，就可以存储任何类型数据
    map1 := make(map[string]interface{})
    map1["name"] = "dajiang"
    map1["age"] = 18
    fmt.println(map1)
    // slice，切片定义成空接口类型，也可以存放任何类型数据
    s1 := make([]any, 0, 10)
    s1 = append(s1, 1, "12312", false, a1, a2)
    fmt.println(s1)
    //数组空接口，数组里面的值默认是nil，也可以存放任何数据类型
    var arr [4]interface{}
    fmt.println(arr)
    arr[0] = 3
    arr[1] = "2"
    arr[2] = s1
    arr[3] = true
    fmt.println(arr)
}

4. 接口嵌套

接口可以嵌套其他接口，即一个接口可以继承多个别的接口。这时，如果要实现这个接口，必须实现它继承的所有接口的方法。

package main
import (
    "fmt"
)
type aa interface {
    test1()
}
type bb interface {
    test2()
}
// cc 接口嵌套  cc :  test1()/test2()/test3()
// 如果要实现接口cc，那么需要实现这个三个方法。那这个对象就有3个接口可以转型。
type cc interface {
    aa // 导入aa接口中的方法
    bb
    test3()
}
// dog7 编写一个结构体实现接口cc
type dog7 struct {
}
func (dog dog7) test1() {
    fmt.println("test1")
}
func (dog dog7) test2() {
    fmt.println("test2")
}
func (dog dog7) test3() {
    fmt.println("test3")
}
func main() {
    // dog 拥有4种形态： dog7 、cc 、 bb 、 aa
    var dog dog7 = dog7{}
    dog.test1()
    dog.test2()
    dog.test3()
    // 接口对象只能调用自己接口里面的方法
    var a aa = dog
    a.test1()
    //a.test2() // 向上转型之后只能调用它自己对应的方法
    var b bb = dog
    b.test2()
    //c三个方法都可以调用
    var c cc = dog
    c.test1()
    c.test2()
    c.test3()
}

5. 接口断言

接口断言用于检查接口变量是否持有特定类型的值，并获取该值。被断言的对象必须是接口类型，否则会报错
它有两种形式：不安全断言和类型安全的断言。

不安全断言
instance := 接口对象.(实际类型)
如果不满足类型断言，程序将发生panic报错。

package main
import "fmt"
// 断言  t := i.(t)   t：t就是i接口是t类型的  i：接口   t:类型
// 语法：t,ok:= i.(t) ok 隐藏返回值，如果断言成功 ok就是true、否则就是false
func main() {
    //assertsstring("11111111111")
    assertsstring(true) // panic: interface conversion: interface {} is bool, not string
}
// 判断一个变量是不是string类型的
func assertsstring(i interface{}) {
    // 如果断言失败，则会抛出 panic 恐慌，程序就会停止执行。
    s := i.(string)
    fmt.println(s)
}

类型安全的断言
instance, ok := 接口对象.(实际类型)
语法：t,ok:= i.(t) ok 隐藏返回值，如果断言成功 ok就是true、否则就是false
如果断言失败，ok将会是false，而instance将会是类型的零值，并且不会触发panic。

接口断言代码示例

package main
import "fmt"
// 断言  t := i.(t)   t：t就是i接口是t类型的  i：接口   t:类型
// 语法：t,ok:= i.(t) ok 隐藏返回值，如果断言成功 ok就是true、否则就是false
func main() {
    //assertsstring("11111111111")
    assertsint("中国")
}
// 断言失败的情况，我们希望程序不会停止。
func assertsint(i any) {
    r, ok := i.(int)
    if ok {
        fmt.println("是我们期望的结果 int")
        fmt.println(r)
    } else {
        fmt.println("不是我们期望的结果，无法执行预期操作")
    }
}

多个预期结果判断
通过switch来判断 switch i.(t)

i 必须是接口类型
i.(type)必须在switch中使用

package main
import "fmt"
// 通过switch来判断  switch i.(t)
type i interface{}
// 如果断言的类型同时实现了switch 多个case匹配，默认使用第一个case
// 所以要把范围更小的匹配放前面
func testassert(i interface{}) {
    // switch i.(type) 接口断言
    //i.(type)必须在switch中使用
    switch i.(type) {
    case string:
        fmt.println("变量为string类型")
    case int:
        fmt.println("变量为int类型")
    case nil:
        fmt.println("变量为nil类型")
    case map[string]int:
        fmt.println("map类型")
    case interface{}:
        fmt.println("变量为interface{}类型")
    //空接口与i一样
    case i:
        fmt.println("变量为i类型")
    // .....
    default:
        fmt.println("未知类型")
    }
}
func main() {
    testassert("string")
    testassert(1)
    var i i      // 没有初始化空接口时，默认值为 nil类型 不属于i类型
    var i2 i = 1 // 只有赋值了之后，才是对应的类型
    testassert(i)
    testassert(i2)
    //map类型
    j := make(map[string]int)
    testassert(j)
}