GO 语言的方法？？

GO 中的方法是什么？

前面我们有分享到 GO 语言的函数，他是一等公民，那么 GO 语言中的方法和函数有什么区别呢？

GO 语言中的方法实际上和函数是类似的，只不过在函数的基础上多了一个参数，这个参数在 GO 语言中被称为 receiver 参数

例如我们可以这么来申明一个方法：

func (xx T/*T) helloworld(入参参数列表) (返回值列表) {
    // 具体实现
}

demo 中的 helloworld 方法就绑定到了 receiver T 类型上，这个 helloworld 方法，我们可以通过使用 T 类型或者 *T 来进行调用，例如：

var tt T
tt.helloworld(入参参数列表)
var pt *T
pt.helloworld(入参参数列表)

看着还是挺简单的对吗？对于使用的时候我们需要注意这些问题：

GO 语言中原生的类型，是不能作为上述的 receiver 的，例如 int，slice，map等等都是不行的，只能是我们自定义的类型
方法只能有一个 receiver 参数，只能绑定一个，不能绑定多个
receiver 参数类型本身不能是指针或者是接口类型，这里非常需要注意

如图：receiver 参数类型本身不能是指针类型

如图：receiver 参数类型本身不能是接口类型

对于方法，是绑定了一个 receiver 类型的参数，那么这个参数是不是很像 C++ 里面的入参呢？

func helloworld(xx T/*T, 其他入参) (返回值列表){
    // 具体实现
}

所以在 GO 语言里面，我们能够明白一个方法所绑定类型的实例，实际上就是一个普通函数的第一个参数

就像这样

func (t T) helloworld()  ==  helloworld(t T)
func (pt *T) helloworld()  ==  helloworld(pt *T)

那么，对于上述绑定的类型，有 T 也有 *T ，如何去选择呢？什么时候用 T 什么时候又用 *T 呢？

此处 T 叫做值类型， *T 叫做指针类型，选择不同的类型，

如果选择 T 类型，那么这是一个值传递类型的，在调用 helloworld 方法的时候，实际上就是传了一个 T 类型实例的副本，那么如果在 helloworld 方法中对 t 做了一些变动，那么只会影响副本，对于原来的 T 类型实例，是不会有影响的
如果选择了 *T 类型，那么这就是一个指针类型的，调用 helloworld 方法的时候，传的就是类型 T 的实例地址，这个时候 helloworld 内部如果对 t 做了一些变动，都会体现到原来的 T 的实例上

这个理解方式实际上就和咱们普通函数中传入的参数是一样的，传值和传地址的区别

一个简单的 demo ，再来加深一下：

定义个 TT 类型的结构，成员有 Name
定义 Hello1 方法绑定 TT，定义 hello2 方法绑定 *TT
新建一个 TT 类型的变量 t，分别去调用 hello1 和 hello2
新建一个 *TT 类型的变量 pt，分别去调用 hello1 和 hello2

可以看到上述程序的结果如下：

name ==
name ==  hello2
name ==
name ==  hello2

从上述 demo 中就可以看出，实际上 GO 语言对于我们调用方法的时候是做了隐式转换，无论是值类型的实例，还是指针类型的实例，都是可以去调用绑定了值类型的方法，也可以去调用绑定了指针类型的方法

只不过得到的结果，就要看具体方法是绑定的值类型，还是指针类型了

所以我们如何去选择 receiver 的类型到此就很清楚了吧？

如果我们期望要去修改 receiver 类型的实例，那么就用指针类型，如果不期望修改，则使用值类型

当然，如果我们是要考虑到性能，就要使用传地址的方式较好

方法的集合

GO 里面虽然没有类，没有对象，没有继承，但是关于面向对象里面的内容在 GO 里面完全可以使用组合的方式来进行实现

所以对于GO 里面是如何组合的的基本知识我们要搞清楚，前提我们就先要弄明白方法的集合是如何玩的

在 GO 语言里面，我们在给接口变量复制，使用结构体嵌入或者接口嵌入，使用类型别名的时候，都是会涉及到方法集合的，但是具体要看某一个实例包含哪些方法集合，我们就可以来演练一下

定义 ITT 接口，里面有 2 个方法 Hello1() , Hello2()
定义 TT 结构体，实现上述接口，其中 Hello1() 绑定 TT ， Hello2() 绑定 *TT
查看 nil 转成 ITT 的方法集合，TT 的方法集合，*TT 的方法集合

type ITT interface{
   Hello1()
   Hello2()

}

type TT struct{}

func (t TT)Hello1(){}

func (pt *TT)Hello2(){}

// 打印方法集合
func GetMethodSet(i interface{}){
   v := reflect.TypeOf(i)
   et := v.Elem()
    num := et.NumMethod()
    if num == 0 {
      fmt.Println(et, "methond num is 0" )
      return
    }
   // 有方法集合
   fmt.Println(et,"mthond set is :")
   for i:=0;i<num;i++{
      fmt.Println("---",et.Method(i).Name)
   }
}


func main(){
   var t TT
   var pt * TT
   // 先查看 nil 接口的方法集合
   GetMethodSet((*ITT)(nil))
   // 查看 TT 的方法集合
   GetMethodSet(&t)
   // 查看 *TT 的方法集合
   GetMethodSet(&pt)
}

运行结果如下：

可以查看到上述案例，绑定类型为 TT 的，方法集合只有 1 个，绑定类型为 *TT 的方法集合有 2 个，可以看得出来

**T 类型的方法集合是包含了 T 类型和 T 类型

T 类型的方法集合是包含了 T 类型

对于 GO 语言里面的组合，总的来说有三种，这个可以多多尝试和写 demo 练习：

接口中嵌入接口

type ITT interface{
    hello1()
}
type ITT2 interface{
    hello2()
}
type ITT3 interface{
    ITT 
    ITT2 
}

接口中嵌入接口，最终的接口方法个数是取和数，此处我们要注意的地方就是方法名如果重复，也是可以正常得到方法集合，具体使用接口中的方法，还是要看实例是如何实现的

结构体中嵌入接口

type ITT interface{
    hello1()
    hello2()
}
type ITT2 interface{
    hello2()
    hello3()
}
type TT struct{
    ITT 
    ITT2
}
// 此时 TT  的方法集合就存在 hello2() 是冲突的，因此此处就需要 TT 去实现自己的 hello2()
func (TT)hello2(){}

结构体中嵌入接口，如果遇到同名的方法，GO 语言会优先选择结构体自己实现的方法，如果结构体自己未实现，则会将接口中的同名方法提升到自己的结构体中来

结构体中嵌入结构体

结构体中嵌入结构体，就要注意嵌入的结构体是值类型的还是指针类型的，例如：

type TT struct{
    TT1
    *TT2
}

那么 TT 的方法集合是什么？ *TT 的方法集合是什么？

TT 的方法集合就是按照正常值传递的来，等于 TT1 的方法集合加上 *TT2 的方法集合

*TT 的方法集合按照地址传递的来，等于 *TT1的方法集合加上 *TT2 的方法集合

那么类型别名的方法集合又是如何去查看的，有什么需要注意的地方吗？

那么还是上述方法集合中的案例，我们分别给结构体 TT 定一个别名，TTB，给接口类型 ITT 定义一个 ITTB ，此时来查看别名的方法集合，与其原有类型的方法集合是否有差距

上述程序运行结果如下：

main.ITT mthond set is :
--- Hello1
--- Hello2
main.ITT mthond set is :
--- Hello1
--- Hello2
main.TT mthond set is :
--- Hello1
main.TT mthond set is :
--- Hello1
*main.TT mthond set is :
--- Hello1
--- Hello2
*main.TT mthond set is :
--- Hello1
--- Hello2