• 定义一个结构体,将函数和结构体绑定在一起的东西就是方法

• 格式:
  func (接收者名称 接收者类型)函数名称(形参列表)(返回值列表){
  逻辑语句;
  }

• Go语言中的函数可以和任何类型绑定, 但是一般用于和结构体绑定

• 注意点:

  1.方法和函数的区别在于, 函数可以直接调用(通过包名.函数名称), 而方法只能通过绑定的数据类型对应的变量来调用(变量.函数名称)

  2.函数名称和方法名称可以重名

type Person struct{
  name string
  age int
}
func (Person)say(){
  fmt.Printf("Hello")
}

p := Person{"xxz",18}
p.say()//"Hello"

• 如果指定了接收者名称,那么调用方法时会将调用者传递给接收者
  • 简单理解:可以把接收者看做函数的形参
• 以下第一段代码表示的是值传递

type Person struct{
  name string
  age int
}
func (per Person)say(){
  fmt.Println("Hello",per.name)
}
p := Person{"xxz",18}
p.say()//"Hello xxz"

• 以下代码为地址传递
• 如果为以下代码,那么编译器会自动将结构体的地址取出来传递给函数

type Person struct{
  name string
  age int
}
func (per *Person)setAge(age int){
  per.age = age
}

per := Person{"xxz",18}
per.say()//"Hello xxz"
//p := &per
//(*p).setAge(666)
per.setAge(666) // 底层相当于(&per).setAge(666)
fmt.Println(per)//{"xxz",666}

---

Go语言接口

• 1.如何定义一个接口

  type USB interface {
  函数名称(形参列表)(返回值列表)
  函数名称(形参列表)(返回值列表)
  }

• 接口内只实现了函数的声明,没有实现

• Go语言中实现一个接口, 不需要做额外的声明, 只要某种数据类型绑定了所有接口中的方法就是实现了这个接口

• 实现接口之后的特性

  • 只要某种数据类型实现了接口, 那么就可以使用接口变量保存这种数据类型

  • 只要某种数据类型实现了接口, 那么就可以使用接口变量调用接口中声明的方法

/*
需求:定义一个函数,实现电器的打开和关闭
*/
type USB interface{
  start()
  end()
}
type Computer struct{
  name string
}
func (c Computer)start(){
  fmt.Println(c.name,"被打开了")
}
func (c Computer)end(){
  fmt.Println(c.name,"被关闭了")
}

type Phone struct{
  name string
}
func (ph Phone)start(){
  fmt.Println(ph.name,"被打开了")
}
func (ph Phone)end(){
  fmt.Println(ph.name,"被关闭了")
}

func main(){
  var in USB
  var cm Computer = Computer{"三星"}
  Option(cm)
  var ph Phone = Phone{"苹果"}
  Option(ph)
}
function Option(in USB){
  in.start()
  in.end()
}

• 注意点
  1.接口中只能有方法的声明, 不能有方法的实现

  2.接口中只能有方法的声明, 不能有变量的声明

  3.只有实现了接口中声明的所有方法, 才算实现了接口, 才能使用接口变量保存

  4.在实现接口的时候, 方法名称,形参列表,返回值列表必须一模一样

  5.接口和结构体一样, 可以嵌套

  6.接口和结构体一样, 嵌套时不能嵌套自己(自己搞自己)

  7.可以将集接口变量赋值给子集接口变量,不可以将子集接口变量赋值给超集接口变量(无论实际的数据类型是否已经实现了超集的所有方法)

  8.接口中不能出现同名的方法声明

---

空接口

• 空接口相当于其他语言的Object类型
• 空接口可以保存任何类型的数据

var value interface{}

• 数组和字典一般是用来保存相同类型数据的,但是我们可以利用空接口使它们保存不同的类型的数据

var arr [3]interface{}
arr[0] = 1
arr[1] = "lnj"
arr[2] = false
fmt.Println(arr)

接口类型转换(类型断言)

• 当一个结构体实现了中所有的方法,那么我们称这个结构体实现了这个接口
• 当一个结构体实现了这个接口,我们可以通过接口变量来保存这个结构体变量
• 当这个接口变量保存了这个结构体变量,那么可以通过调用接口的方法来实现结构体调用这个方法
• 但是接口变量不能调用接口中没有的方法,也不能调用结构体的属性,要想调用接口以外的方法和变量,我们只能通过接口类型转换来实现

---

• 方法一:
  通过value,ok := 接口变量名称.(具体数据类型)
• 转换成功ok值为True,value拿到转换后的结构体
• 转换的类型和接口保存的类型不一样时ok为false

type USB interface{
  start()
}

type Computer struct{
  name string
}
func (cm Computer)start(){
  fmt.Println(cm.name,"被打开了")
}

func main(){
  var cm Computer = Computer{"华硕"}
  in USB := cm
  //fmt.Println(in.name) 报错
  value,ok := in.(Computer)
  fmt.Println(value.name)//"华硕"
  fmt.Println(ok)//True
}

• 方法二
  通过 value := 接口变量名.(type)配合switch
• 会将接口类型变量转换为对应的原始类型之后赋值给value

cm := 接口变量名.(type)
    switch cm := in.(type) {
    case Computer:
        fmt.Println(cm)
        cm.say()
    default:
        fmt.Println("不是Person类型")
    }

cm := Computer{"惠普"}
    var sce []interface{} = []interface{}{1, 3.14, false, "lnj", cm}
    // 需求: 获取切片中保存的每一个数据的原始类型
    for key, value := range sce {
        switch temp := value.(type) {
        case int:
            fmt.Println("第",key, "个元素是int类型")
        case float64:
            fmt.Println("第",key, "个元素是float64类型")
        case bool:
            fmt.Println("第",key, "个元素是bool类型")
        case string:
            fmt.Println("第",key, "个元素是string类型")
        case Computer:
            fmt.Println("第",key, "个元素是Computer类型")
            temp.say()
        }
    }

• 方法三:
  定义一个类似与转接口的空接口用来保存要调用的属性或方法所在的结构体的类型
• 第一种:把抽象接口类型转换为具体的接口类型
• 第二种:把抽象的接口类型转换为结构体类型

var in interface{} = Computer{"华硕"}
//第一种
if value,ok := in.(USB);ok{
  value.start()
}
//第二种
if value,ok := in.(Computer);ok{
  value.start()
}