• Go没有类似python语言中类class的概念，但依旧有method

  • 类型方法定义格式如下
    func (a mytype) method_name(x type)(y type){ return y }
  • 调用方式：
    instance.method(args) -> (type).func(instance, args)

• 通过显示的说明receive来实现与某个类型的组合

  package main
  import "fmt"
  
  type A struct{
      Name Sting
  }
  
  func main() {
      a := A{}         //实例化结构体
      a.Method_Print() //结构体调用方法
  }
  
  func (a A) Method_Print() { // 显示的说明这是结构体的方法.
      fmt.Println("This is a method for struct A")
  }
  
  /*输出
  This is a method for struct A
  */

• 只能为同一个包package中的类型定义方法
• Receiver可以时类型的值或者指针
• 不存在方法的重载

• 可以只用值或指针来调用方法，编译器会自动完成转换

  package main
  import "fmt"
  
  type A struct {
      Name string
  }
  
  type B struct {
      Name string
  }
  
  func main() {
      a := A{}                //实例化结构体
      a.Method_Print()        //结构体调用方法
      fmt.Println(a.Name)     //指针传递时，不用使用`*a.Name`,解释器自动识别
  
      b := B{}
      fmt.Println(b.Name)
      b.Method_Print()
  }
  
  func (a *A) Method_Print() { //方法传递结构体指针
      a.Name = "maozi"
      fmt.Println("This is a method for struct A")
  }
  
  func (b B) Method_Print() { //方法:传递结构
      b.Name = "Sazi" //这种方式只能进行值的拷贝，无法进行更改结构体属性
      fmt.Println("This is a method for struct B")
  }
  
  /*输出
  a.Method_Print---   This is a method for struct A
  a.Name---           maozi
  b.Name--            //空值，修改失败
  b.Method_Pring      This is a method for struct B
  */

• 从某种意义上来说，方法是函数的语法糖，因为receiver其实就是方法所接受的第一个参数

• 如果外部结构和嵌入的结构体存在同名方法，则优先调用外部结构体的方法

• 类型别名不会拥有底层类型所附带的方法,可以为任一底层类型（int…）绑定一个方法

  package main
  import "fmt"
  
  type INT int //自定义一个类型INT,底层为int类型
  
  func main() {
      var a INT
      a.Method_Print()
  
  }
  
  func (a *INT) Method_Print() { //为int类型绑定一个方法
      fmt.Println("This is a method for int type ")
  }
  
  /*输出
  a.Method_Print---This is a method for int type
  */

• 方法可以调用结构中非公开的字段

• Method Values 和 Method Expressions
  • Method Value 是包装后的状态对象，总是与特定的对象实例关联在一起

  • 调用方式类似python类的调用方式，先实例化一个类，在通过.属性调用

  • Method Expression是直接类型.method(var) 的方式

  package main
  import "fmt"
  
  type INT int //定义一个INT
  
  func main() {
      var a INT
      a.Method_Print()       //method value调用方式
      (*INT).Method_Print(a) //method expression调用方式
  }
  
  func (a *INT) Method_Print() { //为int类型绑定一个方法
      fmt.Println("This is a method for int type ")
  }
  /*输出
  a.Method_Print---This is a method for int type
  */

• 类方法名称冲突类似与字段的名称冲突，按继承顺序

• 类方法访问权限：大写首字母表示外部可以访问，小写表示结构体类型的私有字段，私有字段和方法只能在同一个包中调用，只有公有方法（首字母大写）可以在包外调用

  package main
  import "fmt"
  
  type A struct {
      name string //小写首字母，私有字段
  } 
  
  func main() {
      a := A{}
      a.Method_Print() //method value调用方式
  }
  
  func (a *A) Method_Print() {                                    //
      a.name = "123"                                              //方法可以访问私有字段
      fmt.Println("This is a method for struct type ")
  }
  
  /*输出
  a.Method_Print---This is a method for int type
  */

声明一个底层类型位int的类型，实现调用一个方法就递增250， 如x:=0,调用a.Increase(num)后，a从0变为250

```go
package main
import "fmt"

type Ad int                       //声明底层类型为int类型
func main() {
    var x Ad
    x.Add(250)                   //method value调用方式,方法传递参数num=100
    fmt.Println(a)
}
func (ad *Ad) Add(num int) {    //为int类型绑定一个方法
    *ad += Ad(num)              //强制类型转换为底层Ad---int型
}

/*输出
a--->250
*/
```

如果对您有帮助，请给予推荐，谢谢！