对象就是简单的一个值或者变量，并且拥有其方法，而方法是某种特定类型的函数。
方法的声明和普通函数的声明类似，只是在函数名字前面多了一个参数。这个参数把这个方法绑定到这个参数对应的类型上。
package geometry
import "math"
type Point struct { X, Y float64 }
// 普通函数
func Distince(p, q Point) float64 {
return math.Hypot(q.X - p.X, q.Y - p.Y)
}
// Point 类型的方法
func (p Point)Distince(q Point) float64 {
return math.Hypot(q.X - p.X, q.Y - p.Y)
}
附加的参数 p 称为方法的接收者。接收者不使用特殊名(比如 this 或者 self)。
表达式 p.Distance 称为选择子（selector）, 因为它为接受者 p 选择合适的 Distince 方法。
由于主调函数会复制每个实参变量，如果函数需要更新一个变量，或者如果一个实参太大而我们希望避免复制整个实参。我们必须使用指针来传递变量的地址。
func (p *Point) ScaleBy(factor float64) {
p.X *= factor;
p.Y *= factor;
}
命令类型（Point）和指向他们的指针（* Point）是唯一可以出现在接收者声明处的类型。
在真实的程序中，如果 Point 的任何一个方法使用指针接收者，那么所有的 Point 方法都应该使用指针接收者。
如果方法要求一个 *Point 接收者，我们可以使用简写：
p.ScaleBy(2)
编译器会对变量进行 &p 的隐私转换。只有变量才允许这么做，包括结构体字段，像 p.X 和数组或者 slice 元素，比如 perim[0]。
Point(1,2).ScaleBy(2) // 编译错误，不能获得 Poing 类型字面量的地址
如果实参接收者是 * Point 类型，以 Point.Distance 方式调用Point类型的方法是合法的。编译器自动插入一个隐式的 * 操作符。
p := Point{1, 2}
pptr := &p
pptr.Distance(q)
(*pptr).Distance(q)
// IntList 是整形链表
// * IntList 的类型 nil 代表空列表
type IntList struct {
Value int
Tail *IntList
}
// Sum 返回表元素的总和
func (list *IntList) Sum() int {
if list == nil {
return 0
}
return list.Value + list.Tail.Sum()
}
import "image/color"
type Point struct{X, Y float 64}
type ColoredPoint struct {
Point
Color color.RGBA
}
var cp ColoredPoint
cp.X = 1
能够通过类型为 ColoredPoint 的接收者调用内嵌类型 Point 的方法。
red := color.RGBA{255, 0, 0, 255}
blue := color.RGBA{0, 0, 255, 255}
var p = ColoredPoint{Point{1, 1}, red}
var q = ColoredPoint{Point{5, 4}, blue}
p.ScaleBy(2)
p.Distnace(q.Point)
Point 的方法都被纳入到 ColorPoint 类型中。
在 go 语言，Point 类型不是 ColoredPoint 类型的基类。
ColoredPoint 包含一个Point，并且它有两个另外的方法 Distance 和 ScaleBy 来自 Point。如果考虑具体实现，实际上，内嵌的字段会告诉编译器生成额外的包装方法来调用 Point 声明的方法，这相当于以下代码。
func (p ColoredPoint) Distance(q Point) float64 {
return p.Point.Distance(q)
}
func (p* ColoredPoint) ScaleBy(factor float64) {
p.Point.ScaleBy(factor)
}
匿名字段类型可以是指向命名类型的指针，这个时候，字段和方法间接地来自所指向的对象。
结构体类型可以拥有多个匿名字段。声明 ColoredPoint:
type ColoredPoint struct {
Point
color.RGBA
}
那么这个类的值可以拥有 Point 所有的方法和 RGBA 所有的方法，以及任何其他直接在 ColoredPoint 类型中声明的方法。当编译器处理选择子（比如 p.ScaleBy）的时候，首先，先查找直接声明的方法 ScaleBy, 之后在从来自 ColoredPoint 的内嵌字段的方法进行查找，这里的方法经过一次提升；最后从 Point 和 RGBA 中内嵌的方法中进行查找，这里的方法经过2次提升。
如果同一个级别有两个同名的函数提升，则编译器会报错。如Point 和 color.RGBA 都有 Scaleby 函数。
p.Dsitance 可以赋予一个方法变量，他是一个函数，把方法（Point.Distance）绑定到一个接收者 p 上。函数只需要提供实参而不需要提供接收者就能够调用。
p := Point{1, 2}
q := Point{4, 6}
distanceFromP := p.Distance // 方法变量
fmt.Println(distanceFromP(q))
与方法变量相关的是方法表达式。在方法表达式写成 T.f 或者(*T).f，其中 T 是类型，是一种函数变量，把原来方法的接收者替换成函数的第一个形参，因此它可以像平常的安徽省南一样调用。
package main
import (
"fmt"
"math"
)
type Point struct{ X, Y float64 }
func (p Point) Distance(q Point) float64 {
return math.Hypot(q.X-p.X, q.Y-p.Y)
}
func (p *Point) ScaleBy(factor float64) {
p.X *= factor
p.Y *= factor
}
func main() {
p := Point{1, 2}
q := Point{4, 6}
distance := Point.Distance // 方法表达式
fmt.Println(distance(p, q))
scale := (*Point).ScaleBy
scale(&p, 2)
fmt.Println(p) //{2, 4}
fmt.Printf("%T\n", scale) // func(*Point, float64)
}
type IntSet struct {
words []uint64
}
可以定义为
type IntSet []uint64
使用时把 s.words 换成 *s。
尽管这个版本的 IntSet 和之前的基本相同，但是它允许其他包内的方法读取和改变这个 slice。换句话说，表达式 *s 可以在其他包内使用，s.words 只能在定义 IntSet 的包内使用。
另一个结论是Go语言封装的单元是包而不是类型。无论是函数内的代码还是方法内的代码，结构体类型内的字段对于同一个包中的所有代码都是可见的。
封装提供了三个优点。
第一，因为使用方不能直接修改对象的变量，所以不需要更多的语句来检查变量的值。
第二，隐藏实现细节可以防止使用方依赖的属性发生改变，使得设计者可以更加灵活地改变 API 的实现而不破坏兼容性。
第三，防止使用者肆意地改变对象内部的变量。