Go语言程序设计-第6章--方法

Go语言程序设计-第6章–方法

对象就是简单的一个值或者变量，并且拥有其方法，而方法是某种特定类型的函数。

6.1 方法的声明

方法的声明和普通函数的声明类似，只是在函数名字前面多了一个参数。这个参数把这个方法绑定到这个参数对应的类型上。

package geometryimport "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 方法。

6.2 指针接收者的方法

由于主调函数会复制每个实参变量，如果函数需要更新一个变量，或者如果一个实参太大而我们希望避免复制整个实参。我们必须使用指针来传递变量的地址。

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 := &ppptr.Distance(q)
(*pptr).Distance(q)

• nil 是一个合法的接收者

// IntList 是整形链表
// * IntList 的类型 nil 代表空列表
type IntList struct {Value intTail *IntList
}// Sum 返回表元素的总和
func (list *IntList) Sum() int {if list == nil {return 0}return list.Value + list.Tail.Sum()
}

6.3 通过结构体内嵌组成类型

import "image/color"type Point struct{X, Y float 64}type ColoredPoint struct {PointColor 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 {Pointcolor.RGBA
}

那么这个类的值可以拥有 Point 所有的方法和 RGBA 所有的方法，以及任何其他直接在 ColoredPoint 类型中声明的方法。当编译器处理选择子（比如 p.ScaleBy）的时候，首先，先查找直接声明的方法 ScaleBy, 之后在从来自 ColoredPoint 的内嵌字段的方法进行查找，这里的方法经过一次提升；最后从 Point 和 RGBA 中内嵌的方法中进行查找，这里的方法经过2次提升。
如果同一个级别有两个同名的函数提升，则编译器会报错。如Point 和 color.RGBA 都有 Scaleby 函数。

6.4 方法变量与表达式

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 mainimport ("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 *= factorp.Y *= factor
}func main() {p := Point{1, 2}q := Point{4, 6}distance := Point.Distance // 方法表达式fmt.Println(distance(p, q))scale := (*Point).ScaleByscale(&p, 2)fmt.Println(p)            //{2, 4}fmt.Printf("%T\n", scale) // func(*Point, float64)
}

6.5 示例：位向量

6.6 封装

type IntSet struct {words []uint64
}

可以定义为

type IntSet []uint64

使用时把 s.words 换成 *s。
尽管这个版本的 IntSet 和之前的基本相同，但是它允许其他包内的方法读取和改变这个 slice。换句话说，表达式 *s 可以在其他包内使用，s.words 只能在定义 IntSet 的包内使用。

另一个结论是Go语言封装的单元是包而不是类型。无论是函数内的代码还是方法内的代码，结构体类型内的字段对于同一个包中的所有代码都是可见的。

封装提供了三个优点。
第一，因为使用方不能直接修改对象的变量，所以不需要更多的语句来检查变量的值。
第二，隐藏实现细节可以防止使用方依赖的属性发生改变，使得设计者可以更加灵活地改变 API 的实现而不破坏兼容性。
第三，防止使用者肆意地改变对象内部的变量。