声明方法

func (t Type) 方法名(传入参数) (返回值) {
    方法体
}

和声明函数相比，声明方法需要在func后面添加Type类型的t，t可以在方法中被访问到。

基本用法

初始化

例1:

// 声明animal结构体
type animal struct {
   name string
   age int
   class string
   weight float32
}

// 声明animal类型的方法 getName
func (a animal) getName() {
   fmt.Printf("I am %s. n" , a.name)
}

func main()  {
   a1 := animal{name:"Tom",age:3,weight:11.5,class:"猫"}
   a1.getName() // 调用animal结构体实例的方法
}

如上示例，我们声明了animal类型的结构体，并声明了animal类型的方法getName。然后声明了animal结构体的实例a1，a1就具有了animal的属性和方法。

方法不仅仅可以隶属于结构体类型，还可以隶属于非接口、非指针类型的其它任何自定义类型。
例2:

// 声明自定义类型test为go语言的基本类型int
type test int

// 声明 test类型的方法printTest
func (t test) printTest()  {
   fmt.Println("I am t",  t)
}

func main()  {
   var t test
   t = 10
   t.printTest() // print I am t 10
}

上面的例子中，我们使用关键词type定义了test类型，属于go语言的基本类型int；然后声明了test类型的方法printTest

自定义类型是使用 type关键词声明的数据类型，可以是结构体（struct）、基本数据类型、函数。如：type i int，type f func。

同一个类型的方法名称是不允许重复的，方法名和字段名之间也不允许重复，如果重复定义在编译期会报错。

函数代替方法

如上面的例1，我们也可以使用函数达到相同的效果。
例3:

// 声明animal结构体
type animal struct {
   name string
   age int
   class string
   weight float32
}

// 声明函数getName
func getName(a animal) {
   fmt.Printf("I am %s. n" , a.name)
}

func main()  {
   a1 := animal{name:"Tom",age:3,weight:11.5,class:"猫"}
   getName(a1) // 调用getName函数
}

我们定义getName函数，函数的接收参数是animal类型，调用getName函数，传入a1，也达到了和例1相同的目的。

既然函数能达到和方法相同的目的，那为什么还要有方法呢？我认为主要有以下两个原因：

Go语言不是传统的面向对象的语言，它没有类的概念。通过结构体和方法可以加强Go语言面向对象的特性，模拟类的作用。https://golang.org/doc/faq#Is_Go_an_object-oriented_language
隶属于不同类型的方法可以重名，而函数不可以重名。

嵌套类型的方法

在结构体一节我们说到过，当结构体本身字段不存在时，会往被嵌套结构体的“深层”寻找。Go语言由浅入深逐层查找，找到了对应的字段就返回其值，并停止查找。对于方法也是相同的逻辑，Go语言会基于嵌套结构，由浅入深逐层查找，根据方法名调用对应的方法。
例4：

// 声明animalName结构体
type animalName struct {
   firstName string
   lastName string
}

// 声明animal结构体
type animal struct {
   animalName
   age int
   class string
   weight float32
}

func (an animalName) getAnimalName()  {
   fmt.Printf("My name is %s %s", an.firstName, an.lastName)
}

func main()  {
   a1 := animal{
      animalName: animalName{
         firstName:"tom",
         lastName:"steven",
      },
      age: 3,
      class:"猫",
      weight:12.5,
   }
   a1.getAnimalName() // print My name is tom steven
}

在上面的例子中，我们定义了animal结构体类型和嵌套的animalName结构体类型。给animalName类型定义了getAnimalName方法，在执行a1.getAnimalName()方法时，Go语言逐层查找到animalName类型的getAnimalName方法并调用。

值类型和指针类型

前面例子中我们声明的方法都属于值类型，方法还可以属于指针类型。

和函数的参数类型相似，值类型是值的副本，当我们在方法内修改副本的值时，如果是非引用类型就不会修改原值，如果是引用类型会修改原值；指针类型是指针地址的副本，所以我们在方法内的修改都会修改原值。
例5：

// 声明animalName结构体
type animalName struct {
   firstName string
   lastName string
}

// 声明animal结构体
type animal struct {
   animalName
   age int
   class string
   weight float32
}

func (an animalName) setAnimalName(firstName,lastName string)  {
   an.firstName =  firstName
   an.lastName = lastName
}

func (an *animalName) setAnimalNamePoint(firstName,lastName string)  {
   an.firstName =  firstName
   an.lastName = lastName
}

func main()  {
   a1 := animal{
      animalName: animalName{
         firstName:"tom",
         lastName:"steven",
      },
      age: 3,
      class:"猫",
      weight:12.5,
   }
   // print 修改前：a1.firstName=tom  a1.lastName=steven
   fmt.Printf("修改前：a1.firstName=%s  a1.lastName=%s n", a1.firstName,a1.lastName)
   a1.setAnimalName("jerry","williams") // 修改a1的firstName和lastName
   // print 修改后：a1.firstName=tom  a1.lastName=steven
   fmt.Printf("修改后：a1.firstName=%s  a1.lastName=%s n", a1.firstName,a1.lastName) 

   a2 := animal{
      animalName: animalName{
         firstName:"tom",
         lastName:"steven",
      },
      age: 3,
      class:"猫",
      weight:12.5,
   }

   // print 修改前：a2.firstName=tom  a2.lastName=steven
   fmt.Printf("修改前：a2.firstName=%s  a2.lastName=%s n", a2.firstName,a2.lastName)
   a2.setAnimalNamePoint("jerry","williams") // 修改a2的firstName和lastName
   // print 修改后：a2.firstName=jerry  a2.lastName=williams 
   fmt.Printf("修改后：a2.firstName=%s  a2.lastName=%s n", a2.firstName,a2.lastName)
}