接口这部分教程有两个部分。

什么是接口？


在 Go 中，接口是一组方法签名。当一个类型为接口中的所有方法提供定义时，就可以说它实现了接口。它与 OOP 世界非常相似。接口指定类型应具有的方法，类型决定如何实现这些方法。

例如，WashingMachine 可以是具有方法签名 Cleaning() 和 Drying() 的接口。任何提供 Cleaning() 和 Drying()__ 定义的类型都被认为实现了 WashingMachine 接口。

声明并实现接口


让我们通过一个程序来创建和实现一个接口。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. //interface definition
  8. type VowelsFinder interface {  
  9.     FindVowels() []rune
  10. }
  12. type MyString string
  14. //MyString implements VowelsFinder
  15. func (ms MyString) FindVowels() []rune {  
  16.     var vowels []rune
  17.     for _, rune := range ms {
  18.         if rune == 'a' || rune == 'e' || rune == 'i' || rune == 'o' || rune == 'u' {
  19.             vowels = append(vowels, rune)
  20.         }
  21.     }
  22.     return vowels
  23. }
  25. func main() {  
  26.     name := MyString("Sam Anderson")
  27.     var v VowelsFinder
  28.     v = name // possible since MyString implements VowelsFinder
  29.     fmt.Printf("Vowels are %c", v.FindVowels())
  30. }

Run in playground

在程序第 8 行中创建了一个 VowelsFinder 接口类型，它具有一个方法 FindVowels() []rune。

下一行中 MyString 类型被创建。

程序第 15 行中，我们将方法 **FindVowels() []rune 添加到接收器类型 MyString。现在 MyString 实现了 VowelsFinder** 接口。这与 Java 等其他语言完全不同，其中类必须明确声明它使用 implements 关键字实现接口。如果类型包含接口中声明的所有方法**，在 Go 中就不需要，因为 Go 的接口是隐式实现的**。
**
程序第 28 行中，我们将类型为 MyString 的 name 分配给 VowelsFinder 类型的 v。这是被允许的，因为 MyString 实现了 VowelsFinder。 v.FindVowels() 在下一行调用MyString 类型的 FindVowels 方法并输出字符串 Sam Anderson 中的所有元音。程序输出 Vowels are [a e o]。

日常中使用接口


上面的例子告诉我们如何创建和实现接口，但它并没有真正展示接口的实际用途。 如果我们在上面的程序中使用 name.FindVowels() 而不是 v.FindVowels()，它也会工作，并且不会使用创建的接口。

现在让我们来看一下接口的实际用法。

我们将编写一个简单的程序，根据员工的个人工资计算公司的总支出。为了描述简洁方便点，我们假设所有费用均以美元计算。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type SalaryCalculator interface {  
  8.     CalculateSalary() int
  9. }
  11. type Permanent struct {  
  12.     empId    int
  13.     basicpay int
  14.     pf       int
  15. }
  17. type Contract struct {  
  18.     empId  int
  19.     basicpay int
  20. }
  22. //salary of permanent employee is sum of basic pay and pf
  23. func (p Permanent) CalculateSalary() int {  
  24.     return p.basicpay + p.pf
  25. }
  27. //salary of contract employee is the basic pay alone
  28. func (c Contract) CalculateSalary() int {  
  29.     return c.basicpay
  30. }
  32. /*
  33. total expense is calculated by iterating though the SalaryCalculator slice and summing  
  34. the salaries of the individual employees  
  35. */
  36. func totalExpense(s []SalaryCalculator) {  
  37.     expense := 0
  38.     for _, v := range s {
  39.         expense = expense + v.CalculateSalary()
  40.     }
  41.     fmt.Printf("Total Expense Per Month $%d", expense)
  42. }
  44. func main() {  
  45.     pemp1 := Permanent{1, 5000, 20}
  46.     pemp2 := Permanent{2, 6000, 30}
  47.     cemp1 := Contract{3, 3000}
  48.     employees := []SalaryCalculator{pemp1, pemp2, cemp1}
  49.     totalExpense(employees)
  50. }

Run in playground

在程序第7行中使用了一个方法 CalculateSalary() int 声明了接口 SalaryCalculator 。

公司有两种员工，第 11 和 17 行定义了结构 Permanent 和 Contract。长期雇员的工资是 basicpay 和 pf 的总和，而对于合同雇员来说，只有 basicpay。第 23 和 28 行中 CalculateSalary 方法中代码相对应的实现了这一点。通过声明此方法，Permanent 和 Contract 现在都实现了 SalaryCalculator 接口。

第 36 行中声明的 totalExpense 函数表达了使用接口的美妙之处。此方法将SalaryCalculator 接口 []SalaryCalculator 切片作为参数。第 49 行我们将一个包含Permanent 和 Contract 类型的切片传递给 totalExpense 函数。totalExpense 函数通过调用相应类型的 CalculateSalary 方法来计算费用，这在第 39 行中完成。

程序输出

  1. Total Expense Per Month $14050

这样做的最大好处是 totalExpense 可以扩展到任何新员工类型，而无需更改任何代码。让我们说公司增加了一种具有不同薪资结构的新类型的员工 Freelancer 。这个Freelancer可以在切片参数中传递给 totalExpense ，甚至没有一行代码更改为totalExpense 函数。这个方法将做它应该做的事情，因为 Freelancer 也将实现SalaryCalculator 接口:)

让我们修改这个程序，添加新的 Freelancer（自由职业者） 员工。自由职业者的工资是每小时工资和总工作小时数的乘积。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type SalaryCalculator interface {  
  8.     CalculateSalary() int
  9. }
  11. type Permanent struct {  
  12.     empId    int
  13.     basicpay int
  14.     pf       int
  15. }
  17. type Contract struct {  
  18.     empId    int
  19.     basicpay int
  20. }
  22. type Freelancer struct {  
  23.     empId       int
  24.     ratePerHour int
  25.     totalHours  int
  26. }
  28. //salary of permanent employee is sum of basic pay and pf
  29. func (p Permanent) CalculateSalary() int {  
  30.     return p.basicpay + p.pf
  31. }
  33. //salary of contract employee is the basic pay alone
  34. func (c Contract) CalculateSalary() int {  
  35.     return c.basicpay
  36. }
  38. //salary of freelancer
  39. func (f Freelancer) CalculateSalary() int {  
  40.     return f.ratePerHour * f.totalHours
  41. }
  43. /*
  44. total expense is calculated by iterating through the SalaryCalculator slice and summing  
  45. the salaries of the individual employees  
  46. */
  47. func totalExpense(s []SalaryCalculator) {  
  48.     expense := 0
  49.     for _, v := range s {
  50.         expense = expense + v.CalculateSalary()
  51.     }
  52.     fmt.Printf("Total Expense Per Month $%d", expense)
  53. }
  55. func main() {  
  56.     pemp1 := Permanent{
  57.         empId:    1,
  58.         basicpay: 5000,
  59.         pf:       20,
  60.     }
  61.     pemp2 := Permanent{
  62.         empId:    2,
  63.         basicpay: 6000,
  64.         pf:       30,
  65.     }
  66.     cemp1 := Contract{
  67.         empId:    3,
  68.         basicpay: 3000,
  69.     }
  70.     freelancer1 := Freelancer{
  71.         empId:       4,
  72.         ratePerHour: 70,
  73.         totalHours:  120,
  74.     }
  75.     freelancer2 := Freelancer{
  76.         empId:       5,
  77.         ratePerHour: 100,
  78.         totalHours:  100,
  79.     }
  80.     employees := []SalaryCalculator{pemp1, pemp2, cemp1, freelancer1, freelancer2}
  81.     totalExpense(employees)
  83. }

Run in playground

我们在第 22 行添加了 Freelancer 结构，并在第 39 行声明了 CalculateSalary 方法。由于 Freelancer 结构也实现了 SalaryCalculator 接口，所以在 totalExpense 方法中不需要修改其他代码。我们在 main 方法中添加了几个Freelancer 雇员。这个程序打印，

  1. Total Expense Per Month $32450

接口的内部组成


接口可以被认为是由元组 (type, value) 在内部组成的。 type 是接口的基础具体类型，value 保存具体类型的值。

让我们通过一个程序来更好地理解。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type Worker interface {  
  8.     Work()
  9. }
  11. type Person struct {  
  12.     name string
  13. }
  15. func (p Person) Work() {  
  16.     fmt.Println(p.name, "is working")
  17. }
  19. func describe(w Worker) {  
  20.     fmt.Printf("Interface type %T value %v\n", w, w)
  21. }
  23. func main() {  
  24.     p := Person{
  25.         name: "Naveen",
  26.     }
  27.     var w Worker = p
  28.     describe(w)
  29.     w.Work()
  30. }

Run in playground

Worker 接口有一个方法 Work()，Person 结构类型实现了该接口。在第 27 行，我们将 Person 类型的变量 p 赋值给 Worker 类型的 w。现在 w 的具体类型是 Person，它包含了一个 name 字段为 Naveen 的 Person。第 17 行中的 describe 函数打印了接口的值和具体类型。这个程序输出

  1. Interface type main.Person value {Naveen}  
  2. Naveen is working

我们在接下来的章节中更多地讨论如何提取接口的底层的值。

空接口

具有零方法的接口称为空接口。即它表示为 interface{}。由于空接口的方法为零，因此所有类型都实现空接口。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func describe(i interface{}) {  
  8.     fmt.Printf("Type = %T, value = %v\n", i, i)
  9. }
  11. func main() {  
  12.     s := "Hello World"
  13.     describe(s)
  14.     i := 55
  15.     describe(i)
  16.     strt := struct {
  17.         name string
  18.     }{
  19.         name: "Naveen R",
  20.     }
  21.     describe(strt)
  22. }

Run in playground

在上面的程序中，在第 7 行中，describe(i interface{}) 函数将空接口作为参数，因此可以传递任何类型。

我们将 string，int 和 struct 传递给第 13,15 和 21 行中的 describe 函数。这个程序输出，

  1. Type = string, value = Hello World  
  2. Type = int, value = 55  
  3. Type = struct { name string }, value = {Naveen R}


类型断言


类型断言用于提取接口的基础值。

i.(T) 是用于获取具体类型为 T 的接口 i 的基础值的语法。

一个程序胜过千言万语😀，让我们写一个类型断言。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func assert(i interface{}) {  
  8.     s := i.(int) //get the underlying int value from i
  9.     fmt.Println(s)
  10. }
  12. func main() {  
  13.     var s interface{} = 56
  14.     assert(s)
  15. }

Run in playground

第 13 行中 s 的具体类型是 int。我们在第 8 行中使用语法 i.(int) 获取 i 的 int 值。该程序输出 56。

如果上述程序中的具体类型不是 int，会发生什么呢？

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func assert(i interface{}) {  
  8.     s := i.(int) 
  9.     fmt.Println(s)
  10. }
  12. func main() {  
  13.     var s interface{} = "Steven Paul"
  14.     assert(s)
  15. }

Run in playground

在上面的程序中，我们将 s 具体类型 string 传递给 assert 函数，该函数尝试从中提取 int值。该程序将报错 panic: interface conversion: interface {} is string, not int。

要解决上述问题，我们可以使用语法

  1. v, ok := i.(T)

如果 i 的具体类型是 T，则 v 将具有 i 的基础值，ok 将为真。

如果 i 的具体类型不是 T，那么 ok 将为 false 并且 v 将具有类型 T 的零值并且程序将不会报错。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func assert(i interface{}) {  
  8.     v, ok := i.(int)
  9.     fmt.Println(v, ok)
  10. }
  12. func main() {  
  13.     var s interface{} = 56
  14.     assert(s)
  15.     var i interface{} = "Steven Paul"
  16.     assert(i)
  17. }

Run in playground

当 Steven Paul 传递给 assert 函数时，ok 将为 false，因为 i 的具体类型不是 int 而 v为 0。该程序将输出，

  1. 56 true  
  2. 0 false


类型Switch


类型 switch 用于将接口的具体类型与各种 case 语句中指定的多种类型进行比较。它类似于 switch case。唯一的区别是 cases 指定类型而不是正常 switch 中的值。

type switch 的语法类似于 Type 断言。在类型断言的语法 i.(T) 中，类型 T 应该替换为类型 switch 的关键字 type。让我们看看下面的程序如何工作。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func findType(i interface{}) {  
  8.     switch i.(type) {
  9.     case string:
  10.         fmt.Printf("I am a string and my value is %s\n", i.(string))
  11.     case int:
  12.         fmt.Printf("I am an int and my value is %d\n", i.(int))
  13.     default:
  14.         fmt.Printf("Unknown type\n")
  15.     }
  16. }
  18. func main() {  
  19.     findType("Naveen")
  20.     findType(77)
  21.     findType(89.98)
  22. }

Run in playground

上面程序第 8 行中，switch i.(type) 指定了类型 switch。每个 case 语句都将 i 的具体类型与特定类型进行比较。如果任何情况匹配，则输出相应的语句。该程序输出，

  1. I am a string and my value is Naveen  
  2. I am an int and my value is 77  
  3. Unknown type

第 20 行中 89.98 是 float64 类型，不匹配任何情况，因此在最后一行输出 Unknown type。

还可以将类型与接口进行比较。如果我们有一个类型，并且该类型实现了一个接口，则可以将该类型与它实现的接口进行比较。

让我们写一个程序。

  1. package main
  3. import "fmt"
  5. type Describer interface {  
  6.     Describe()
  7. }
  9. type Person struct {  
  10.     name string
  11.     age  int
  12. }
  14. func (p Person) Describe() {  
  15.     fmt.Printf("%s is %d years old", p.name, p.age)
  16. }
  18. func findType(i interface{}) {  
  19.     switch v := i.(type) {
  20.     case Describer:
  21.         v.Describe()
  22.     default:
  23.         fmt.Printf("unknown type\n")
  24.     }
  25. }
  26. func main() {  
  27.     findType("Naveen")
  28.     p := Person{
  29.         name: "Naveen R",
  30.         age:  25,
  31.     }
  32.     findType(p)
  33. }

Run in playground

在上面的程序中，Person 结构实现了 Describer 接口。在第 19 行中的 case 语句中，将 v 与 Describer 接口类型进行比较。 p 实现了 Describer，因此满足了这种情况，在第 32 行中 findType(p)，调用 Describe() 方法。

程序输出

  1. unknown type  
  2. Naveen R is 25 years old


原文链接


https://golangbot.com/interfaces-part-1/