Go语言的接口与反射

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

美女图片没啥用，就是为了好看

本文还在完善中...

go总体而言是一门比较好入门的语言，许多特性都很精简易懂，但是接口与反射除外。他们真的让人头疼，不知道是自身资质问题还是怎么着，总是觉得很多书上写的不够精简明了。。而我，亚楠老猎人，今天就是要受苦试着把它给攻克了。

接口

你可以用很多词语来形容golang，但“传统”肯定不能用。因为，它里面没有类和继承的概念。

你觉得这简直不可思议，怎么可能这样，那不是意味着海量的重复代码。并没有，Go通过很灵活的一个概念，实现了很多面向对象的行为。没错，这个概念就是“接口”。

Go 没有类：数据（结构体或更一般的类型）和方法是一种松耦合的正交关系。

我们来看看接口的特性。

接口被隐式实现

类型不需要显式声明它实现了某个接口，接口是被隐式地实现的。

什么意思？就是说只要你把接口声明的方法都实现了，那么就认为你实现了这个接口了。无需像其他语言那样在显眼的地方表明 implements 接口名称 ,比如php中你可能需要这样子：

<?php
interface Cinema
{
  public function show(Order $show,$num);
}
// 显示正常
class Order implements Cinema
{
  public $number='0011排';
  public function show(Order $show,$num)
  {
    echo $show->number.$num;
  }
}
$face= new Order();
$face->show(new Order,$num='3人');//输出 0011排3人

而在golang中，你只需要这个样子：

// 一个简单的求正方形面积的例子
package main

import "fmt"

// 形状接口
type Shape interface {
    Area() float32
}

// 输出形状面积
func PrintArea(shape Shape) {
    fmt.Printf("The square has area: %f\n", shape.Area())
}

// 正方形结构体
type Square struct {
    side float32
}

// 正方形面积
func (sq *Square) Area() float32 {
    return sq.side * sq.side
}

func main() {
    square := new(Square)
    square.side = 5
    PrintArea(square)
}

上面的程序定义了一个结构体 Square 和一个接口 Shape，接口有一个方法 Area()，而Square实现了这个方法，虽然没有显示声明。

这时你发现，PrintArea这个函数居然可以直接接受了Square类型的参数，尽管函数定义里，参数是Shape接口类型的。
也就是说，golang认为你已经用Square结构体实现了Shape接口。

如果，我们对代码稍作修改,给接口定义中增加周长(Perimeter)方法

// 形状接口
type Shape interface {
    Area()      float32
    Perimeter() float32
}

其他不作改动，你就会发现编译器报错了

cannot use square (type *Square) as type Shape in argument to DescArea:
    *Square does not implement Shape (missing Perimeter method)

报错信息说的很明了，Shape还有个方法Perimeter，但是Square却未实现它。虽然还没有人去调用这个方法，但是编译器也会提前给出错误。

下面我们准备开始了解继承与多态，在开始之前，我们记住这句话

一个接口可以由多种类型实现，一种类型也可以实现多个接口。

接口实现继承

一个接口可以包含一个或者多个其他的接口，这相当于直接把这些内嵌接口的方法列举在外层接口中一样。
当一个类型包含（内嵌）另一个类型（实现了一个或多个接口）的指针时，这个类型就可以使用（另一个类型）所有的接口方法。

比如，还是那个Shape的例子，我们这次增加一个要素，颜色，来生成多彩的正方形。

package main

import "fmt"

// 形状接口
type Shape interface {
    Area() float32
}

// 颜色接口
type Color interface {
    Colors() []string
}

// 多彩的形状接口
type ColorfulShape interface {
    Shape
    Color
    Name()
}

比如上面的例子，最后的ColorfulShape就包含了Shape和Color接口，此外还有自身特有的Name()方法。

接口实现多态

我们很容易扩展之前的代码，比如你可以联想到正方形的好兄弟，长方形，于是..

package main

import "fmt"

// 形状接口
type Shape interface {
    Area() float32
}

// 输出形状面积
func PrintArea(shape Shape) {
    fmt.Printf("The square has area: %f\n", shape.Area())
}

// 正方形结构体
type Square struct {
    side float32
}

// 正方形面积
func (sq *Square) Area() float32 {
    return sq.side * sq.side
}

// 长方形结构体
type Rectangle struct {
    length, width float32
}

// 长方形面积
func (r Rectangle) Area() float32 {
    return r.length * r.width
}

func main() {
    r := Rectangle{5, 3} 
    q := &Square{5}     
    shapes := []Shape{r, q}
    fmt.Println("Looping through shapes for area ...")
    for key, _ := range shapes {
        fmt.Println("Shape details: ", shapes[key])
        fmt.Println("Area of this shape is: ", shapes[key].Area())
    }
}

在main方法的for循环中，虽然只知道shapes[key]是一个Shape对象，但是它却能自动变成Square或者Rectangle对象，还可以调用各自的Area方法。是不是很厉害？

通过上面的例子，我们可以发现：

接口其实像一种契约，实现类型必须满足它（实现其定义的方法）。
接口描述了类型的行为，规定类型可以做什么。
接口彻底将类型能做什么，以及如何做分离开来。
这些特点使得相同接口的变量在不同的时刻表现出不同的行为，这就是多态的本质。

使用接口使代码更具有普适性。

总结一下golang里面的继承与多态：

继承：用组合实现：内嵌一个（或多个）包含想要的行为（字段和方法）的类型；多重继承可以通过内嵌多个类型实现
多态：用接口实现：某个类型的实例可以赋给它所实现的任意接口类型的变量。类型和接口是松耦合的，并且多重继承可以通过实现多个接口实现。Go 接口不是 Java 和 C# 接口的变体，而且：接口间是不相关的，并且是大规模编程和可适应的演进型设计的关键。

类型断言

前面用接口实现多态时，在最后main方法的for循环里，接口类型变量
shapes[key]中可以包含任何类型的值，那么如何检测当前的对象是什么类型的呢？

答案就是使用类型断言。比如

v := var.(类型名)

这里的var必需得是接口变量，比如shapes[key]。

如果我们直接这么写

v := shapes[key].(*Square)

那肯是会报错的，因为shapes[key]也可能是Rectangle类型的，为了避免错误发生，我们可以使用更安全的方法进行断言：

if v, ok := shapes[key].(*Square); ok {
    // 相关操作
}

如果转换合法，v 是 shapes[key] 转换到类型 Square 的值，ok 会是 true；否则 v 是类型 Square 的零值，ok 是 false，也没有运行时错误发生。

备注: 不要忽略 shapes[key].(*Square) 中的 * 号，否则会导致编译错误：impossible type assertion: Square does not implement Shape (Area method has pointer receiver)。

方法集与接口

Go 语言规范定义了接口方法集的调用规则：

类型 *T 的可调用方法集包含接受者为 *T 或 T 的所有方法集
类型 T 的可调用方法集包含接受者为 T 的所有方法
类型 T 的可调用方法集不包含接受者为 *T 的方法

举例说明

package main

import (
    "fmt"
)

type List []int

func (l List) Len() int {
    return len(l)
}

func (l *List) Append(val int) {
    *l = append(*l, val)
}

type Appender interface {
    Append(int)
}

func CountInto(a Appender, start, end int) {
    for i := start; i <= end; i++ {
        a.Append(i)
    }
}

type Lener interface {
    Len() int
}

func LongEnough(l Lener) bool {
    return l.Len()*10 > 42
}

func main() {
    // A bare value
    var lst List
    // compiler error:
    // cannot use lst (type List) as type Appender in argument to CountInto:
    //       List does not implement Appender (Append method has pointer receiver)
    // CountInto(lst, 1, 10) 
    if LongEnough(lst) { // VALID:Identical receiver type
        fmt.Printf("- lst is long enough\n")
    }

    // A pointer value
    plst := new(List)
    CountInto(plst, 1, 10) //VALID:Identical receiver type
    if LongEnough(plst) {
        // VALID: a *List can be dereferenced for the receiver
        fmt.Printf("- plst is long enough\n")
    }
}

在 lst 上调用 CountInto 时会导致一个编译器错误，因为 CountInto 需要一个 Appender，而它的方法 Append 只定义在指针上。在 lst 上调用 LongEnough 是可以的,因为 Len 定义在值上。

在 plst 上调用 CountInto 是可以的，因为 CountInto 需要一个 Appender，并且它的方法 Append 定义在指针上。在 plst 上调用 LongEnough 也是可以的，因为指针会被自动解引用。

空接口

空接口是个很厉害的存在，因为他什么方法都没有。那么，你就可以认为所有的结构体都实现了这个接口。哪怕这个结构体什么事情都不做。这大概就是所谓的“无招胜有招吧”。

反射

Reflection（反射）在计算机中表示程序能够检查自身结构的能力，尤其是类型。它是元编程的一种形式，也是最容易让人迷惑的一部分。

这是一个强大的工具，除非真得有必要，否则应当避免使用或小心使用。

变量最基本的信息其实就是：类型和值。而反射包中的reflect.Type还有reflect.Value就是用来返回对象的类型和值。比如：

var x float64 = 3.14
fmt.Println(reflect.TypeOf(x))  // float64
fmt.Println(reflect.ValueOf(x)) // 3.14

反射与接口的联系

那么反射和接口到底有什么关系呢？

观察上面两个函数的定义就可以明显看出来了,比如TypeOf：

// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {
    eface := *(*emptyInterface)(unsafe.Pointer(&i))
    return toType(eface.typ)
}

反射方法首先把变量转化为空接口（按照上文所述，所有结构体都可以转化为空接口）。

反射的一些方法

对于 float64 类型的变量 x，如果 v := reflect.ValueOf(x)，那么 v.Kind() 返回 reflect.Float64 ，所以下面的表达式是 true

v.Kind() == reflect.Float64

通过反射修改(设置)值

如果我们想要修改x的值怎么办，最简单的方法当然是

x = 3.1415

还有一种方法就是使用SetFloat方法，但是如果你这么使用

v.SetFloat(3.1415)

却会报错reflect.Value.SetFloat using unaddressable value。这是为什么呢？因为v不是可设置的（这里并不是说值不可寻址）。是否可设置是 Value 的一个属性，并且不是所有的反设值都有这个属性：可以使用 CanSet() 方法测试是否可设置。

当 v := reflect.ValueOf(x) 函数通过传递一个 x 拷贝创建了 v，那么 v 的改变并不能更改原始的 x。要想 v 的更改能作用到 x，那就必须传递 x 的地址 v = reflect.ValueOf(&x)。

但是通过 Type() 我们看到 v 现在的类型是 *float64 并且仍然是不可设置的。

要想让其可设置我们需要使用 Elem() 函数，这间接的使用指针：

v = v.Elem()

现在 v.CanSet() 返回 true 并且 v.SetFloat(3.1415) 设置成功了！代码如下：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x)
    // setting a value:
    // v.SetFloat(3.1415) // Error: will panic: reflect.Value.SetFloat using unaddressable value
    fmt.Println("settability of v:", v.CanSet())
    v = reflect.ValueOf(&x) // Note: take the address of x.
    fmt.Println("type of v:", v.Type())
    fmt.Println("settability of v:", v.CanSet())
    v = v.Elem()
    fmt.Println("The Elem of v is: ", v)
    fmt.Println("settability of v:", v.CanSet())
    v.SetFloat(3.1415) // this works!
    fmt.Println(v.Interface())
    fmt.Println(v)
}

反射结构

有些时候需要反射一个结构类型。NumField() 方法返回结构内的字段数量；通过一个 for 循环用索引取得每个字段的值 Field(i)。

我们同样能够调用签名在结构上的方法，例如，使用索引 n 来调用：Method(n).Call(nil)。

package main

import (
    "fmt"
    "reflect"
)

type NotknownType struct {
    s1, s2, s3 string
}

func (n NotknownType) String() string {
    return n.s1 + " - " + n.s2 + " - " + n.s3
}

// variable to investigate:
var secret interface{} = NotknownType{"Ada", "Go", "Oberon"}

func main() {
    value := reflect.ValueOf(secret) // <main.NotknownType Value>
    typ := reflect.TypeOf(secret)    // main.NotknownType
    // alternative:
    //typ := value.Type()  // main.NotknownType
    fmt.Println(typ)
    knd := value.Kind() // struct
    fmt.Println(knd)

    // iterate through the fields of the struct:
    for i := 0; i < value.NumField(); i++ {
        fmt.Printf("Field %d: %v\n", i, value.Field(i))
        // error: panic: reflect.Value.SetString using value obtained using unexported field
        //value.Field(i).SetString("C#")
    }

    // call the first method, which is String():
    results := value.Method(0).Call(nil)
    fmt.Println(results) // [Ada - Go - Oberon]
}

标准库中运用的反射

Go语言的标准库中其实也大量运用了反射，比如说fmt包中的Printf,就使用了反射来分析它的...参数。

看看Printf函数的定义

// Sprintf formats according to a format specifier and returns the resulting string.
func Sprintf(format string, a ...interface{}) string {
    p := newPrinter()
    p.doPrintf(format, a)
    s := string(p.buf)
    p.free()
    return s
}

其中的...interface{}就是空接口类型。该函数使用反射，从而得知每个参数的类型。所以，你无需在格式化字符串中使用%u或者%ld来指明参数是unsigned或是long,只需要%d就好了，因为它知道这个参数是什么类型的。

下面是一个简化版的Printf函数，来简要说明其原理

package main

import (
    "os"
    "strconv"
)

type Stringer interface {
    String() string
}

type Celsius float64

func (c Celsius) String() string {
    return strconv.FormatFloat(float64(c),'f', 1, 64) + " °C"
}

type Day int

var dayName = []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}

func (day Day) String() string {
    return dayName[day]
}

func print(args ...interface{}) {
    for i, arg := range args {
        if i > 0 {os.Stdout.WriteString(" ")}
        switch a := arg.(type) { // type switch
            case Stringer:  os.Stdout.WriteString(a.String())
            case int:       os.Stdout.WriteString(strconv.Itoa(a))
            case string:    os.Stdout.WriteString(a)
            // more types
            default:        os.Stdout.WriteString("???")
        }
    }
}

func main() {
    print(Day(1), "was", Celsius(18.36))  // Tuesday was 18.4 °C
}