1.1 什么是方法

通俗的理解为，方法类似于Java类中定义的方法，只能通过该类的实例进行访问，是该类所特有的函数。
它和函数的区别在于方法有一个接收者，给一个函数添加一个接收者，那么它就变成了方法。接收者可以是值接收者，也可以是指针接收者。

1.2 方法的语法

  1. func (t Type) methodName(parameter list)(return list) {
  3. }

示例：

  2. type Employee struct {
  3.     name     string
  4.     salary   int
  5.     currency string // 货币单位
  6. }
  8. // 定义一个方法，用来展示薪资
  9. func (e Employee) displaySalary() {
  10.     fmt.Printf("%s的薪资是%s%d：\n", e.name, e.currency, e.salary)
  11. }
  13. func main() {
  14.     fmt.Println("方法..")
  15.     e1 := Employee{
  16.         name:     "zled",
  17.         salary:   10000,
  18.         currency: "$",
  19.     }
  20.     e1.displaySalary()
  21. }
  23. /*
  24.     zled的薪资是：$10000
  25. */

1.3 定义相同的方法名

类似于java中方法的重载，但与java不同之处在于，java中两个方法的参数不一致也可以理解为重载，但是go中不行，go中同一方法名同一返回类型只能定义一次，不存在参数不同方法不同的情况。也就是说go中允许定义相同的方法名-唯一的限定条件是，返回值不同，参数必须相同。

  2. type Rectangle struct {
  3.     width, height float64
  4. }
  5. type Circle struct {
  6.     radius float64
  7. }
  8. func (r Rectangle) area() float64 {
  9.     return r.width * r.height
  10. }
  11. //该 method 属于 Circle 类型对象中的方法
  12. func (c Circle) area() float64 {
  13.     return c.radius * c.radius * math.Pi
  14. }
  15. func main() {
  16.     fmt.Println("方法..")
  17.     r1 := Rectangle{12, 2}
  18.     r2 := Rectangle{9, 4}
  19.     c1 := Circle{10}
  20.     c2 := Circle{25}
  21.     fmt.Println("Area of r1 is: ", r1.area()) // 长方形面积
  22.     fmt.Println("Area of r2 is: ", r2.area())    
  23.     fmt.Println("Area of c1 is: ", c1.area()) // 圆形面积
  24.     fmt.Println("Area of c2 is: ", c2.area())
  25. }
  27. /*
  28.     Area of r1 is:  24
  29.     Area of r2 is:  36
  30.     Area of c1 is:  314.1592653589793
  31.     Area of c2 is:  1963.4954084936207
  32. */
  • 虽然method的名字一模一样，但是如果接收者不一样，那么method就不一样
  • method里面可以访问接收者的字段
  • 调用method通过.访问，就像struct里面访问字段一样

    1.3 方法于函数

    既然由函数，为什么还要使用方法？
    示例： ```go type Employee struct { name string salary int currency string }

/ displaySalary() method converted to function with Employee as parameter / func displaySalary(e Employee) { fmt.Printf(“Salary of %s is %s%d”, e.name, e.currency, e.salary) }

func main() { e := Employee{ name: “Sam Adolf”, salary: 5000, currency: “$”, } displaySalary(e) }

/ Salary of Sam Adolf is $5000 / ``` 之所以有函数和方法的区分在于：

  1. Go不是纯粹的面向对象的语言，不支持类，这样可以实现类似于类的行为的方法
  2. 对于不同的对象，会有不同的方法与之对应是函数无法实现的，比如求面积，正方形和圆形，计算方式不同，因此可以考虑使用更方便的进行计算(随便可以通过判断条件进行计算)。

    1.4 变量作用域

    作用域就是常量、类型、变量、函数或包在源码中的作用范围。
    Go语言中可以又三个地方声明变量：
  • 函数内定义->局部变量
  • 函数外定义->全局变量
  • 函数定义中的变量(函数或方法上接收值用的变量)->形式参数

    1.5 method继承

    Go中的方法是可以继承的，如果匿名字段实现了一个method，那么包含这个匿名字段的结构体也可以调用该method。