一、method 带有接收者的函数，称之为method。
假设定义了一个struct叫长方形，现在要计算它的面积，那么按照面向过程的思路会如下实现：
packeage main
import "fmt"
type Rectange struct {
width, height float64
}
func area(r Rectangle) float64 {
return r.width*r.height
}
func main() {
r1 := Rectangle(12, 2)
r2 := Rectangle(9, 4)
fmt.Println("Area of r1 is: ", area(r1))
fmt.Println("Area of r2 is: ", area(r2))
}
这段代码中，area不是Rectangle的方法，所以需要将r1,r2作为参数传入以计算面积。我们知道C语言是不能重载的，为了解决新增类型比如圆、五边形等问题则需要为此定义多个不同名的面积计算函数，比如：area_circle、area_triangle。这种方式相对于C++的重载来看不是很优雅，在Go语言中，用了类似的解决方案，即method。
method附属在一个给定的类型上，它的语法和函数的声明语法几乎一样，只是在func后面增减了一个receiver（也就是method所依从的主体），简单点说就是struct拥有方法area。method的语法如下：
func (r ReceiverType) funcName(parameters) (results)
将前面例子改造如下：
package main
import (
"fmt"
"math"
)
type Rectangle struct {
width, height float64
}
type Circle struct {
radius float64
}
func (r Rectangle) area() float64 {
return r.width*r.height
}
func (c Circle) area() float64 {
return c.radius*c.radius*math.pi
}
func main() {
r1 := Rectangle(12, 2)
r2 := Rectangle(9, 4)
c1 := Circle(10)
c2 := Circle(25)
fmt.Println("Area of r1 is: ", r1.area())
fmt.Println("Area of r2 is: ", r2.area())
fmt.Println("Area of c1 is: ", c1.area())
fmt.Println("Area of c2 is: ", c2.area())
}
使用method的时候需要注意以下几点：
（1）虽然method的名字一模一样，但是如果接收者不一样，那么method就不一样。
（2）method里面可以访问接收者的字段。
（3）调用method通过访问，就像struct里面访问字段一样。
在上面的例子中，method方法中的Receiver是以值传递，而非引用传递。实际上，Receiver还可以是指针，二者区别在于：指针作为Receiver会对实例对象的内容发生操作，而普通类型作为Receiver仅仅是以副本作为操作对象，并不对原实例对象发生操作。
method其实不仅仅可以用在struct上，而且可以用在任何自定义的类型、内置类型、struct等上面。当然struct也是自定义类型中的一个特例，你还可以通过如下形式来申明自定义类型：
type typeName typeLiteral
具体例子如下：
type ages int
type money float32
type months map[string]int
实际上自定义类型只是为内置类型定义了一个别名而已，类似于C语言中的typedef，如上面所示用ages替代了int。
二、method继承 method也可以继承，如果匿名字段实现了一个method，那么包含这个匿名字段的struct也能调用该method，举例如下：
package main
import "fmt"
type Human struct {
name string
age int
phone string
}
type Student struct {
Human //匿名字段
school string
}
type Employee struct {
Human //匿名字段
company string
}
//在human上定义一个method
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
func main() {
mark := Student{Human{"Mark", 25, "222-222-YYY"}, "MIT"}
sam := Employee{Human{"Sam", 45, "111-888-XXX"}, "Golang Inc"}
mark.SayHi()
sam.SayHi()
}
三、method重写 method还能重写，类似于匿名字段冲突的处理方式。
我们可以在Emplyee上面定义一个method，重写匿名字段的方法，具体如下：
package main
import "fmt"
type Human struct {
name string
age int
phone string
}
type Student struct {
Human //匿名字段
school string
}
type Employee struct {
Human //匿名字段
company string
}
//Human定义method
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
//Employee的method重写Human的method
func (e *Employee) SayHi() {
fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name, e.company, e.phone)
}
func main() {
mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
mark.SayHi()
sam.SayHi()
}
看了上面的代码是否看到了C++的影子啊，呵呵。
通过这些内容，我们可以设计出基本的面向对象的程序，但是Go语言的面向对象非常简单，没有任何的私有、公有关键字，通过大小写来实现（大写开头的为公有，小写开头的为私有），方法也也同样适用这个原则。