gopl方法和接口

方法声明

写一个简单的方法:

成都创新互联公司-专业网站定制、快速模板网站建设、高性价比华宁网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式华宁网站制作公司更省心,省钱,快速模板网站建设找我们,业务覆盖华宁地区。费用合理售后完善,10年实体公司更值得信赖。

type Point struct{X, Y float64}

// 普通的函数
func Distance(p, q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

// 同样的作用,用方法实现
func (p Point) Distance(q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

接收者:附加的参数 p 称为方法的接收者。
调用方法的时候,接收者在方法名的前面。这样就和声明保持一致:

p := Point{1, 2}
q := Point{4, 6}
fmt.Println(Distance(p, q)) // 函数调用
fmt.Println(p.Distance(q))  // 方法调用

选择子:表达是 p.Distance 称作选择子(selector),因为它为接收者 p 选择合适的 Distance 方法。

指针接收者的方法

对于函数,它会复制每一只实参变量。如果函数需要更新一个变量,或者是因为实参太大而需要避免复制整个实参,就需要使用指针来传递变量的地址。
对于方法的接受者,也可以将方法绑定到指针类型。习惯上遵循如果一个类型的任何一个方法使用指针接收者,那么所有该类型的方法都应该使用指针接收者,即使有些方法不一定需要。
另外,为了防止混淆,不允许本身是指针的类型进行方法声明,会有编译错误:

type p *int
func (p) f() { /*...*/ } // 编译错误:非法的接收者类型

方法变量与表达式

方法变量(method value)

通常是在相同的表达式里使用和调用方法,但是把两个操作分开也是可以的。选择子 p.Distance 可以赋予一个方法变量,它是一个函数,把方法(Point.Distance)绑定到一个接收者 p 上。函数只需要提供实参而不需要提供接收者就能够调用:

p := Point{1, 2}
q := Point{4, 6}
distanceFromP := p.Distance // 方法变量
fmt.Println(distanceFromP(q))

这里 p.Distance 是选择子,把它赋值给变量 distanceFromP,这个变量就是方法变量,并且这个变量是一个函数。
如果包内的 API 调用一个函数值,并且使用者期望这个函数的行为是调用一个特定接收者的方法,方法变量就非常有用。使用方法变量还可以是代码更加简洁:

type Rocket struct { /* ... */ }
func (r *Rocket) Launch() { /* ... */ }

r := new(Rocket)
time.AfterFunc(10 * time.Second, func() { r.Launch() }) // 如果没有方法变量,那么要把执行一个方法包在一个函数里,等到函数被调用后执行
time.AfterFunc(10 * time.Second, r.Launch)  // 使用方法变量,这里 r.Launch 就是一个函数,只是没有赋值给某个变量,没有函数名

函数 time.AfterFunc 的作用是在指定的延迟后调用一个函数。上面说了,方法变量也是函数。

方法表达式(method expression)

调用方法的时候必须提供接收者,并且按照选择子的语法进行调用。
方法表达式,写成 T.f 或者 (*T.f)。
其中 T 是类型,是一种函数变量,把原来方法的接收者替换成函数的第一个形参,因此它可以像平常的函数一样调用:

p := Point{1, 2}
q := Point{4, 6}
distance :=  Point.Distance  // 方法表达式
fmt.Println(distance(p, q))
fmt.Printf("%T\n", distance) // "func(Point, Point) float64"

如果需要一个值来代表多个方法中的一个,而方法都属于同一个类型,方法表达式可以实现让这个值所对应的方法来处理不同的接收者。就是可以把一个方法变成一个函数,函数的变量会增加一个,第一个变量就是原来方法中的接收者。其实各个参数的顺序还是一样的,原本第一个参数在 func 前,现在移动到了 func 后面。 p.Distance(q) 变成了 distance(p, q)。

接口类型

io包定义了很多有用的接口:

  • io.Writer : 抽象了所有写入字节的类型,下面会列举
  • io.Reader : 抽象了所有可以读取字节的类型
  • io.Closer : 抽象了所有可以关闭的类型,比如文件或者网络连接

io.Writer 是一个广泛使用的接口,它负责所有可以写入字节的抽象,包括但不限于下面列举的这些:

  • 文件
  • 内存缓冲区
  • 网络连接
  • HTTP客户端
  • 打包器(archiver)
  • 散列器(hasher)

接口值

接口值,就是一个接口类型的值。分两个部分:

  • 动态类型: 该接口的具体类型
  • 动态值: 该具体类型的一个值
var w io.Writer  // 声明接口,动态类型和动态值都是nil
w = os.Stdout  // 有动态类型,也有动态值
w = io.Writer(os.Stdout)  // 和上面这句等价,把一个具体类型显式转换为接口类型
w = new(bytes.Buffer)  // 有动态类型,也有动态值
w = nil  // 把动态类型和动态值都设置为nil,恢复到声明时的状态

比较接口值

接口值可以用 == 和 != 来比较。动态类型一致,然后动态值相等(使用动态类型的 == 来比较),那么接口值相等。接口值都是nil也是相等的。
可以作为map的key,也可以作为switch语句的操作数,因为可以比较。
动态值可能是不可比较的类型,比如切片。对这样的接口进行比较,就会Panic。把这样的接口用作map的key或者switch语句的操作数时也同样会Panic。所以,仅在能确认接口值包含的动态值可以比较时,才比较接口值。
fmt 包的 %T 打印出来的就是动态类型。在内部实现中,fmt 用反射来拿到接口动态类型的名字。

注意:含有空指针的非空接口

空的接口值(动态类型和动态值都为空)和仅仅动态值为nil的接口值是不一样的。

const debug = true

func main() {
    var buf *bytes.Buffer
    if debug {
        buf = new(bytes.Buffer)
    }
    f(buf)
    if debug {
        // ...使用 buf...
    }
}

// 如果 out 不是 nil,那么会向其写入输出的数据
func f(out io.Writer) {
    // ...其他代码...
    if out != nil {
        out.Write([]byte("done\n"))
    }
}

这里,把一个类型为 *bytes.Buffer 的空指针赋给了 out 参数,此时 out 的动态值为空。但它的动态类型是 *bytes.Buffer。就是说 out 是一个包含空指针的非空接口,所以这里的检查 out != nil 是 true,防御不了这种情况。
对于某些类型,比如 *os.File,空接收值是合法的。但是对于这里的 *buyes.Buffer,要求接收者不能为空,于是运行时会Panic。
这里的解决方案是,把 main 函数中的 buf 类型修改为 io.Writer,从而避免在最开始就把一个功能不完整的值赋给一个接口:

var buf io.Writer
if debug {
    buf = new(bytes.Buffer)
}
f(buf)

类型断言

类型断言是一个作用在接口值上的操作,代码类似于x(T),x是一个接口类型的表达式,而T是一个类型(称为断言类型)。类型断言会检查操作数的动态类型是否满足指定的断言类型。
这里有两种可能:

  • 断言类型T是一个具体类型
  • 断言类型T是一个接口类型

具体类型
如果断言类型T是一个具体类型,断言类型会检查x的动态类型是否就是T。如果检查成功,返回x的动态值,返回的类型就是T。如果检查失败,那么操作崩溃。

接口类型
如果断言类型T是一个接口类型,断言类型会检查x的动态类型是否满足T。如果检查成功,动态值并没有提取出来,仍然是一个接口值,接口值的类型和值部分也不会变,只是结果类型为接口类型T。就是说,这里类型断言就是一个接口值表达式,从一个接口类型变为拥有另外一套方法的接口类型,但保留了接口值中动态类型和动态值部分。如果检查失败还是会崩溃。

类型断言可以返回两个结果,此时操作不会因为检查失败而崩溃。多出来的返回值是一个布尔型,用来指示断言是否成功。按照惯例,一般变量名用ok。如果操作失败,ok为false,而第一个返回值会是断言类型的零值。

类型分支

接口有两种不同的风格。
第一种风格下,典型的比如:io.Reader、io.Writer、fmt.Stringer、sort.Interface、http.Handler 和 error。接口上的各种方法突出了满足这个接口的具体类型之间的相似性,但隐藏了各个具体类型的布局和各自特有的功能。这种风格强调了方法,而不是具体类型。
第二种风格则充分利用了接口值能够容纳各种具体类型的能力,它把接口作为这些类型的联合(union)来使用。类型断言用来在运行时区分这些类型并分别处理。这这种风格中,强调的是满足这个接口的具体类型,而不是这个接口的方法(经常是没变方法的空接口),也不注重信息隐藏。这种风格的接口使用方式称为可识别联合(discriminated union)。
如果对面向对象熟悉,这两种风格分别对应:

  • 子类型多态(subtype polymorphism)
  • 特设多态(ad hoc polymorphism)

使用接口的一些建议

不要一开始就定义接口,每个接口却只是一个单独的实现。这种接口是不必要的抽象,还会有运行时的成本。仅在有两个或多个具体类型需要按统一的方式处理时才需要接口。
上面的建议也有特例,如果接口和类型实现出于依赖的原因不能放在同一个包里边,那么一个接口只有一个具体类型实现也是可以的。在这种情况下,接口是一种解耦两个包的好方式。


文章名称:gopl方法和接口
本文链接:http://bzwzjz.com/article/jghcsc.html

其他资讯

Copyright © 2007-2020 广东宝晨空调科技有限公司 All Rights Reserved 粤ICP备2022107769号
友情链接: 企业网站建设公司 做网站设计 网站建设公司 网站制作 重庆外贸网站建设 成都网站制作 成都网站设计 网站建设改版 企业手机网站建设 上市集团网站建设 定制网站建设多少钱 移动网站建设 外贸网站建设 攀枝花网站设计 成都网站制作 成都商城网站建设 成都网站设计 定制网站设计 成都网站建设 网站设计 成都营销网站建设 营销型网站建设