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

2023-12-31 17:34:15

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

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

6.1 方法的声明

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

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 方法。

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 := &p

pptr.Distance(q)
(*pptr).Distance(q)
  • nil 是一个合法的接收者
// 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()
}

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

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 函数。

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 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)
}

6.5 示例:位向量

6.6 封装

type IntSet struct {
	words []uint64
}

可以定义为

type IntSet []uint64

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

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

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

文章来源:https://blog.csdn.net/houzhizhen/article/details/135317479
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。