[译] part 19: golang 接口 2

https://juejin.im/post/5cacbea75188251b12248542

指针接收者的接口 VS 值接收者的接口

我们在上一篇文章中讨论的所有示例接口都是使用值接收者实现的。也可以使用指针接收者实现接口。在使用指针接收者实现接口时需要注意一些细微之处。让我们使用以下程序了解一下。

  1. package main
  2. import "fmt"
  3. type Describer interface {
  4. Describe()
  5. }
  6. type Person struct {
  7. name string
  8. age int
  9. }
  10. func (p Person) Describe() { //implemented using value receiver
  11. fmt.Printf("%s is %d years old\n", p.name, p.age)
  12. }
  13. type Address struct {
  14. state string
  15. country string
  16. }
  17. func (a *Address) Describe() { //implemented using pointer receiver
  18. fmt.Printf("State %s Country %s", a.state, a.country)
  19. }
  20. func main() {
  21. var d1 Describer
  22. p1 := Person{"Sam", 25}
  23. d1 = p1
  24. d1.Describe()
  25. p2 := Person{"James", 32}
  26. d1 = &p2
  27. d1.Describe()
  28. var d2 Describer
  29. a := Address{"Washington", "USA"}
  30. /* compilation error if the following line is
  31. uncommented
  32. cannot use a (type Address) as type Describer
  33. in assignment: Address does not implement
  34. Describer (Describe method has pointer
  35. receiver)
  36. */
  37. //d2 = a
  38. d2 = &a //This works since Describer interface
  39. //is implemented by Address pointer in line 22
  40. d2.Describe()
  41. }

Run in playground

在上面的程序中的第 13 行,Person结构使用值接收者实现了Describer接口。

正如我们之前已经学过和讨论的方法那样,带有值接收者的方法同时接受指针和值接收者。用值或者值的解引用去调用值方法是合法的。

p1Person类型的值,它在第 29 行中赋值给d1Person实现了d1接口,因此 30 行,将打印Sam is 25 years old.

类似地,在第 32 行中将&p2赋值给d1。 因此第 33 行将打印James is 32 years old.,太棒了:)。

在第 22 行,Address结构使用指针接收者实现Describer接口。 如果上面程序的第 45 行没有被取消注释,我们将看到编译错误main.go:42: cannot use a (type Address) as type Describer in assignment: Address does not implement Describer (Describe method has pointer receiver)。这是因为,Describer接口是使用第地址指针接收者实现的,我们尝试分配一个值类型a,但它没有实现Describer接口。这肯定会让你感到惊讶,因为我们之前已经知道带有指针接收者的方法将同时接受指针和值接收者。那么第 45 行的代码为什么不行呢?

原因是在任何已经是指针或可以寻址的任何类型上调用指针值方法是合法的。而存储在接口中的具体值是不可寻址的,因此编译器不可能自动获取第 45 行a的地址,因此这段代码失败了。

第 47 行是正确的,因为我们将a的地址&a赋值给了d2

该程序的其余部分是通俗易懂的。该程序将打印,

  1. Sam is 25 years old
  2. James is 32 years old
  3. State Washington Country USA

实现多个接口

一个类型可以实现多个接口。让我们看看如何在以下程序中完成此操作。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. type SalaryCalculator interface {
  6. DisplaySalary()
  7. }
  8. type LeaveCalculator interface {
  9. CalculateLeavesLeft() int
  10. }
  11. type Employee struct {
  12. firstName string
  13. lastName string
  14. basicPay int
  15. pf int
  16. totalLeaves int
  17. leavesTaken int
  18. }
  19. func (e Employee) DisplaySalary() {
  20. fmt.Printf("%s %s has salary $%d", e.firstName, e.lastName, (e.basicPay + e.pf))
  21. }
  22. func (e Employee) CalculateLeavesLeft() int {
  23. return e.totalLeaves - e.leavesTaken
  24. }
  25. func main() {
  26. e := Employee {
  27. firstName: "Naveen",
  28. lastName: "Ramanathan",
  29. basicPay: 5000,
  30. pf: 200,
  31. totalLeaves: 30,
  32. leavesTaken: 5,
  33. }
  34. var s SalaryCalculator = e
  35. s.DisplaySalary()
  36. var l LeaveCalculator = e
  37. fmt.Println("\nLeaves left =", l.CalculateLeavesLeft())
  38. }

Run in playground

上面程序在第 7 行和第 11 行分别声明了两个接口SalaryCalculatorLeaveCalculator

在第 15 行中定义的Employee结构,实现了SalaryCalculator接口的DisplaySalary方法和LeaveCalculator接口的CalculateLeavesLeft方法。现在,Employee实现了SalaryCalculatorLeaveCalculator接口。

在第 41 行,我们将e赋值给SalaryCalculator接口类型的变量。在第 43 行,我们将相同的变量e分配给LeaveCalculator接口类型的变量。这就使得Employee类型的变量e实现了SalaryCalculatorLeaveCalculator接口。

程序输出,

  1. Naveen Ramanathan has salary $5200
  2. Leaves left = 25

接口的嵌入

尽管 go 不提供继承,但可以通过嵌入其他接口来创建新接口。

我们来看看是怎么完成的。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. type SalaryCalculator interface {
  6. DisplaySalary()
  7. }
  8. type LeaveCalculator interface {
  9. CalculateLeavesLeft() int
  10. }
  11. type EmployeeOperations interface {
  12. SalaryCalculator
  13. LeaveCalculator
  14. }
  15. type Employee struct {
  16. firstName string
  17. lastName string
  18. basicPay int
  19. pf int
  20. totalLeaves int
  21. leavesTaken int
  22. }
  23. func (e Employee) DisplaySalary() {
  24. fmt.Printf("%s %s has salary $%d", e.firstName, e.lastName, (e.basicPay + e.pf))
  25. }
  26. func (e Employee) CalculateLeavesLeft() int {
  27. return e.totalLeaves - e.leavesTaken
  28. }
  29. func main() {
  30. e := Employee {
  31. firstName: "Naveen",
  32. lastName: "Ramanathan",
  33. basicPay: 5000,
  34. pf: 200,
  35. totalLeaves: 30,
  36. leavesTaken: 5,
  37. }
  38. var empOp EmployeeOperations = e
  39. empOp.DisplaySalary()
  40. fmt.Println("\nLeaves left =", empOp.CalculateLeavesLeft())
  41. }

Run in playground

上面程序的第 15 行中的EmployeeOperations接口是通过嵌入SalaryCalculatorLeaveCalculator接口创建的。

如果一个类型提供了SalaryCalculatorLeaveCalculator接口中存在的方法的方法定义,就可以说实现了EmployeeOperations接口。

Employee结构实现了EmployeeOperations接口,因为它分别在第 29 行和第 33 行中的DisplaySalaryCalculateLeavesLeft方法提供了定义。

在第 46 行,类型为Employeee被赋值给EmployeeOperations类型的empOp。在接下来的两行中,在empOp上调用DisplaySalary()CalculateLeavesLeft()方法。

程序输出,

  1. Naveen Ramanathan has salary $5200
  2. Leaves left = 25

接口的零值

接口的零值是nilnil接口的值和类型都为nil

  1. package main
  2. import "fmt"
  3. type Describer interface {
  4. Describe()
  5. }
  6. func main() {
  7. var d1 Describer
  8. if d1 == nil {
  9. fmt.Printf("d1 is nil and has type %T value %v\n", d1, d1)
  10. }
  11. }

Run in playground

上述程序中的d1nil,此程序将输出

  1. d1 is nil and has type <nil> value <nil>

如果我们尝试在nil接口上调用方法,程序将会发生panic,因为nil接口既没有具体值也没有具体类型。

  1. package main
  2. type Describer interface {
  3. Describe()
  4. }
  5. func main() {
  6. var d1 Describer
  7. d1.Describe()
  8. }

Run in playground

由于上面程序中的d1nil,因此程序将会出现panic: runtime error: invalid memory address or nil pointer dereference [signal SIGSEGV: segmentation violation code=0xffffffff addr=0x0 pc=0xc8527]"

ft_authoradmin  ft_create_time2019-08-03 16:36
 ft_update_time2019-08-03 16:36