Go语言中的函数和方法是两个完全不同的东西。官方的解释是,方法是包含了接收者的函数。到底什么意思呢?

    首先,函数的格式是固定的,func + 函数名 + 入参(可选) + 返回值(可选) + 函数体。 例如

    1. func main() {
    2. fmt.Println("Hello World!")
    3. }

    在golang中有两个特殊的函数,main函数init函数
    main函数作为一个程序的入口,只能有一个。
    init函数在每个package是可选的,可有可无,甚至可以有多个,init函数在你导入该package时程序会自动调用init函数,另外它只会被调用一次,因为当一个package被多次引用时,它只会被导入一次。值得注意的是init函数没有入参和返回值。

    1. package mypackage
    2. import "fmt"
    3. var I int
    4. func init() {
    5. I = 0
    6. fmt.Println("Call mypackage init1")
    7. }
    8. func init() {
    9. I = 1
    10. fmt.Println("Call mypackage init2")
    11. }
    12. // ======================
    13. package main
    14. import (
    15. "mypackage"
    16. "fmt"
    17. )
    18. func main() {
    19. fmt.Println("Hello go.... I = ", mypackage.I)
    20. }
    21. // >>>>>>>>>> output <<<<<<<<<<
    22. // Call mypackage init1
    23. // Call mypackage init2
    24. // Hello go.... I = 1
    25. // 程序自动调用了两个init函数,并且是按照顺序调用的。

    下面这个例子可以看出方法和函数的区别:
    方法在func关键字后是接收者而不是函数名,接收者可以是自己定义的一个类型,这个类型可以是struct,interface,甚至可以重定义基本数据类型。
    这里需要注意一个细节,接收者是指针和非指针(值)的区别,我们可以看到当接收者为指针时,我们可以通过方法改变该接收者的属性,但是非指针类型却做不到。
    这里的接收者和c++中的this指针有一些相似,我们可以把接受者当作一个class,而这些方法就是类的成员函数,当接收者为指针类型是就是c++中的非const成员函数,为非指针时就是const成员函数,不能通过此方法改变累的成员变量。
    因此可以得出,函数没有固定的所属,而方法属于固定的接收者类型。

    1. package main
    2. import "fmt"
    3. type myint int
    4. func (p *myint) mydouble() int {
    5. *p = *p * 2
    6. return 0
    7. }
    8. func (p myint) mysquare() int {
    9. p = p * p
    10. fmt.Println("mysquare p = ", p)
    11. return 0
    12. }
    13. func main() {
    14. var i myint = 2
    15. i.mydouble()
    16. fmt.Println("i = ", i)
    17. i.mysquare()
    18. fmt.Println("i = ", i)
    19. }
    20. // >>>>>>>>>> output <<<<<<<<<<
    21. // i = 4
    22. // mysquare p = 16
    23. // i = 4