Go 语言接口（Interfaces）

Go语言接口不同于其他语言。在Go语言中，该接口是一种自定义类型，用于指定一组一个或多个方法签名，并且该接口是抽象的，因此不允许您创建该接口的实例。但是您可以创建接口类型的变量，并且可以为该变量分配具有接口所需方法的具体类型值。换句话说，接口既是方法的集合，也是自定义类型。

如何创建接口？

在Go语言中，您可以使用以下语法创建接口：

type interface_name interface{

    //方法签名
}

例如：

//创建一个接口
type myinterface interface{
    // 方法
    fun1() int
    fun2() float64
}

此处，接口名称包含在type和interface关键字之间，方法签名包含在花括号之间。

如何实现接口？

在Go语言中，为了实现接口，必须实现接口中声明的所有方法。go语言接口是隐式实现的。与其他语言一样，它不包含实现接口的任何特定关键字。如下例所示:

// Golang程序说明如何
//实现接口
package main

import "fmt"

//创建一个接口
type tank interface {

    // 方法
    Tarea() float64
    Volume() float64
}

type myvalue struct {
    radius float64
    height float64
}

//实现方法
//桶的（Tank）接口
func (m myvalue) Tarea() float64 {

    return 2*m.radius*m.height + 2*3.14*m.radius*m.radius
}

func (m myvalue) Volume() float64 {

    return 3.14 * m.radius * m.radius * m.height
}

func main() {

    // 访问使用桶的接口
    var t tank
    t = myvalue{10, 14}
    fmt.Println("桶的面积 :", t.Tarea())
    fmt.Println("桶的容量:", t.Volume())
}

输出：

桶的面积 : 908
桶的容量: 4396

注意事项

• 接口的零值为nil。

• 当接口包含零个方法时，此类接口称为空接口。因此，所有类型都实现空接口。

  语法：

  interface{}

• 接口类型：该接口有两种类型，一种是静态的，另一种是动态的。静态类型是接口本身，例如下面示例中的tank。但是接口没有静态值，所以它总是指向动态值。
  接口类型的变量，其中包含实现接口的类型的值，因此该类型的值称为动态值，而该类型是动态类型。又称具体值和具体类型。

  示例

  //说明Go程序的概念
  //动态值和类型
  package main
  
  import "fmt"
  
  //创建接口
  type tank interface {
  
      // 方法
      Tarea() float64
      Volume() float64
  }
  
  func main() {
  
      var t tank
      fmt.Println("tank interface值为: ", t)
      fmt.Printf("tank 的类型是: %T ", t)
  }

  输出：

  tank interface值为:  <nil>
  tank 的类型是: <nil>

  在上面的示例中，有一个名为tank的接口。在此示例中，fmt.Println("tank interface值为: ", t) 语句返回该接口的动态值，而 fmt.Printf("tank 的类型是: %T ", t) 语句返回该接口的动态类型，即nil，因为这里的接口不知道谁在实现它。

• 类型断言：在Go语言中，类型断言是应用于接口值的操作。换句话说，类型断言是提取接口值的过程。

  语法：
  

  a.(T)

  在这里，a是接口的值或表达式，T是也称为类型断言的类型。类型断言用于检查其操作数的动态类型是否匹配已断言的类型。如果T是具体类型，则类型断言检查a的给定动态类型是否等于T，这里，如果检查成功进行，则类型断言返回a的动态值。否则，如果检查失败，则操作将出现panic异常。如果T是接口类型，则类型断言检查满足T的给定动态类型，这里，如果检查成功进行，则不提取动态值。

  示例

  //类型断言 
  package main 
    
  import "fmt"
    
  func myfun(a interface{}) { 
    
      //提取a的值
      val := a.(string) 
      fmt.Println("值为: ", val) 
  } 
  func main() { 
    
      var val interface { 
      } = "nhooo"
        
      myfun(val) 
  }

  输出：

  值为:  nhooo

  在上面的示例中，如果将val：= a。（string）语句更改为val：= a。（int），则程序会抛出panic异常。因此，为了避免此问题，我们使用以下语法：

  value, ok := a.(T)

  在这里，如果a的类型等于T，则该值包含a的动态值，并且ok将设置为true。并且如果a的类型不等于T，则ok设置为false并且value包含零值，并且程序不会抛出panic异常。如下面的程序所示：

  示例

  package main
  
  import "fmt"
  
  func myfun(a interface{}) {
      value, ok := a.(float64)
      fmt.Println(value, ok)
  }
  func main() {
  
      var a1 interface {
      } = 98.09
  
      myfun(a1)
  
      var a2 interface {
      } = "nhooo"
  
      myfun(a2)
  }

  输出：

  98.09 true
  0 false

• 类型判断：在Go接口中，类型判断用于将接口的具体类型与case语句中提供的多种类型进行比较。它与类型声明类似，只是有一个区别，即大小写指定类型，而不是值。您还可以将类型与接口类型进行比较。如下例所示：

  示例

  package main
  
  import "fmt"
  
  func myfun(a interface{}) {
  
      //使用类型判断
      switch a.(type) {
  
      case int:
          fmt.Println("类型: int，值:", a.(int))
      case string:
          fmt.Println("\n类型: string，值: ", a.(string))
      case float64:
          fmt.Println("\n类型: float64，值: ", a.(float64))
      default:
          fmt.Println("\n类型未找到")
      }
  }

  输出：

  类型: string，值:  nhooo
  
  类型: float64，值:  67.9
  
  类型未找到

• 接口的使用：当您想要在其中传递不同类型的参数的方法或函数中时，可以使用接口，就像Println()函数一样。或者，当多种类型实现同一接口时，也可以使用接口。