golang中定义的某个interface作为函数的入参时

Posted 2023-04-13

参考技术A 函数的入参是某个interface，那么函数里调用interface里的方法时，如果方法里有修改结构体变量，会修改原有的变量么？

1.方法的接收器是指针，结构体的成员变量是指针变量。变量被修改了。
2.方法的接收器是指针，结构体的成员变量不是指针变量。变量被修改了。
3.方法的接收器不是指针，结构体的成员变量不是指针变量。变量没有被修改了。
4.方法的接收器不是指针，结构体的成员变量是指针变量。变量被修改了。

也就是方法的接收器或者成员变量有一方是指针，那么原来结构体的成员变量就会被修改。

golang基础--Interface接口

• 接口是一个或多个方法签名名的集合，定义方式如下
  type Interface_Name interface { method_a() string method_b() int .... }

• 只要某个类型拥有该接口的所有方法签名，就算实现该接口，无需显示声明实现了那个接口，这称为structural Typing

  package main
  import "fmt"
  
  type USB interface { //定义一个接口：方法的集合
      Name() string //Name方法，返回string
      Connect()     //Connect方法
  }
  
  type PhoneConnecter struct { //定义一个结构
      name string //结构包含一个字段
  }
  
  func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
      return pc.name //该方法命名为接口内的字段
  } //返回结构体字段
  
  func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
      fmt.Println("Connect:", pc.name)
  }
  func main() {
      var a USB                            //定义一个变量为USB接口类型
      a = PhoneConnecter{"PhoneConnecter"} //实例化一个结构体，并赋值给变量（接口）USB
      a.Connect()                          //接口调用其Connect方法，也是结构方法
  }
  
  /*输出
  Connect: PhoneConnecter
  */

• 接口可以作为匿名嵌入其它接口，或嵌入到结构中

  package main
  import "fmt"
  
  type USB interface { //定义一个接口：方法的集合
      Name() string //Name方法，返回string
      Connecter     //嵌入Connecter接口，可以使用Connecter方法
  }
  
  type Connecter interface { //定义另一个接口 Connecter
      Connect() //包含一个接口方法：Connect
  }
  type PhoneConnecter struct { //定义一个结构
      name string //结构包含一个字段
  }
  
  func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
      return pc.name //该方法命名为接口内的字段
  } //返回结构体字段
  
  func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
      fmt.Println("Connect:", pc.name)
  }
  func main() {
      var a USB                            //定义一个变量为USB接口类型
      a = PhoneConnecter{"PhoneConnecter"} //实例化一个结构体，并赋值给变量（接口）USB
      a.Connect()
      Disconnect(a) //接口调用其Connect方法，也是结构方法
  }

• 接口只是方法声明，没有实现调用，没有字段，只能通过绑定的类型方法访问

  package main
  import "fmt"
  
  type USB interface { //定义一个接口：方法的集合
      Name() string //Name方法，返回string
      Connecter     //嵌入Connecter接口，可以使用Connecter方法
  }
  
  type Connecter interface { //定义另一个接口 Connecter
      Connect() //包含一个接口方法：Connect
  }
  type PhoneConnecter struct { //定义一个结构
      name string //结构包含一个字段
  }
  
  func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
      return pc.name //该方法命名为接口内的字段
  } //返回结构体字段
  
  func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
      fmt.Println("Connected:", pc.name)
  }
  func main() {
      var a USB                     //定义一个变量为USB接口类型
      a = PhoneConnecter{"htc M10"} //实例化一个结构体，并赋值给变量（接口）USB
      a.Connect()
      Disconnect(a) //接口调用其Connect方法，也是结构方法
  }
  
  func Disconnect(usb USB) {
      if pc, ok := usb.(PhoneConnecter); ok { //传入结构体，判断赋值是否成功
          fmt.Println("Disconnected:", pc.name)
          return
      }
      fmt.Println("UNknown device.")
  }
  
  /*输出
  Connect: htc M10
  Disconnect:htc M10
  */

• go没有像其他语言继承，如python中的object表示元类，所有的类都继承自object类，go通过接口也类似实现了此定义，因为只要某个类型实现了某个接口的方法，我们就说此类实现了
  这个接口。 因为type empty interface{}---空接口没有任何方法，所以可以理解为所有的接口都实现了空接口的方法（继承）。

  package main
  import "fmt"
  
  type USB interface { //定义一个接口：方法的集合
      Name() string //Name方法，返回string
      Connecter     //嵌入Connecter接口，可以使用Connecter方法
  }
  
  type Connecter interface { //定义另一个接口 Connecter
      Connect() //包含一个接口方法：Connect
  }
  type PhoneConnecter struct { //定义一个结构
      name string //结构包含一个字段
  }
  
  func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
      return pc.name //该方法命名为接口内的字段
  } //返回结构体字段
  
  func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
      fmt.Println("Connected:", pc.name)
  }
  func main() {
      var a USB                     //定义一个变量为USB接口类型
      a = PhoneConnecter{"htc M10"} //实例化一个结构体，并赋值给变量（接口）USB
      a.Connect()
      Disconnect(a) //接口调用其Connect方法，也是结构方法
  }
  
  # func Disconnect(usb interface{}) { //集成空接口，也可以实现
  #   if pc, ok := usb.(PhoneConnecter); ok { //传入结构体，判断赋值是否成功
  #       fmt.Println("Disconnected:", pc.name)
  #       return
  #   }
  #   fmt.Println("UNknown device.")
  #   }
  
  //通过switch判断接口类型：type...switch用法
  func Disconnect(usb interface{}) { //集成空接口，也可以实现
  switch v := usb.(type) {
  case PhoneConnecter:
      fmt.Println("Disconnected:", v.name)
  default:
      fmt.Println("UNknown device.")
  }
  }
  
  /*输出
  Connect: htc M10
  Disconnect:htc M10
  */

• 接口间的转换： 只有子类接口可以转换为父类接口，因为父类接口包含了子类接口，子类接口可以调用父类接口一部分接口方法

• 将对象赋值给接口是，会发生拷贝，而接口内部存储的是只想这个复制品的指针，也就意味着接口无法修改状态，也无法获取指针。

  ...
  func main() {
  pc := PhoneConnecter{"ipad book pro"} //实例化一个结构
  var a Connecter                       //定义a为接口变量
  a = Connecter(pc)                     //接口强制转换
  a.Connect()
  
  pc.name = "Iphone 7"
  a.Connect()
  ...
  
  /*输出
  pc.name= "ipad book pro"    Connected: ipad book pro
  pc.name = "Iphone 7"        Connected: ipad book pro
  */
  }

• 只有当 接口存储的类型和对象都为nil时，接口才等于nil

  package main
  import "fmt"
  
  func main() {
      var a interface{}
      fmt.Println(a == nil)
  
      var p *int = nil
      a = p
      fmt.Println(a == nil)
  }
  
  /*输出
  true
  false
  */

• 接口调用不会做Receiver的自动转换

• 接口同样支持匿名字段的方法

• 接口也可以实现类似OOP(面向对象编程)中的多态

• 空接口可以作为任何类型数据的容器