基于类型系统的面向对象编程语言Go

时间 2019-11-30

原文原文链接

(整理自网络)html

面向对象编程

Go语言的面向对象编程(OOP)很是简洁而优雅。说它简洁，在于它没有了OOP中不少概念，好比：继承、虚函数、构造函数和析构函数、隐藏的this指针等等。说它优雅，是它的面向对象(OOP)是语言类型系统(type system)中的自然的一部分。整个类型系统经过接口(interface)串联，浑然一体。java

类型系统(type system)

不多有编程类的书籍谈及类型系统(type system)这个话题。但实际上类型系统是整个语言的支撑，相当重要。c++

类型系统(type system)是指一个语言的类型体系图。在整个类型体系图中，包含这些内容：编程

基本类型。如byte、int、bool、float等等。
复合类型。如数组(array)、结构体(struct)、指针(pointer)等。
Any类型。便可以指向任意对象的类型。
值语义和引用语义。
面向对象。即全部具有面向对象特征（好比有成员方法）的类型。
接口(interface)。

类型系统(type system)描述的是这些内容在一个语言中如何被关联。好比咱们聊聊Java的类型系统：在Java语言中，存在两套彻底独立的类型系统，一套是值类型系统，主要是基本类型，如byte、int、boolean、char、double、String等，这些类型基于值语义。一套是以Object类型为根的对象类型系统，这些类型能够定义成员变量、成员方法、能够有虚函数。这些类型基于引用语义，只容许new出来（只容许在堆上）。只有对象类型系统中的实例能够被Any类型引用。Any类型就是整个对象类型系统的根 —— Object类型。值类型想要被Any类型引用，须要装箱（Boxing）过程，好比int类型须要装箱成为Integer类型。只有对象类型系统中的类型才能够实现接口（方法是让该类型从要实现的接口继承）。api

在Go语言中，多数类型都是值语义，而且均可以有方法。在须要的时候，你能够给任何类型（包括内置类型）“增长”新方法。实现某个接口(interface)无需从该接口继承（事实上Go语言并无继承语法），而只须要实现该接口要求的全部方法。任何类型均可以被Any类型引用。Any类型就是空接口，亦即 interface{}。数组

给类型增长方法

在Go语言中，你能够给任意类型（包括内置类型，但指针类型除外）增长方法，例如：网络

type Integer int

func (a Integer) Less(b Integer) bool {
    return a < b
}

在这个例子中，咱们定义了一个新类型Integer，它和int没有本质不一样，只是它为内置的int类型增长了个新方法：Less。如此，你就可让整型看起来像个类那样用：数据结构

func main() {
    var a Integer = 1
    if a.Less(2) {
        fmt.Println(a, "Less 2")
    }
}

在学其余语言的时候，不少初学者对面向对象感到很神秘。我在给初学者介绍面向对象的时候，常常说到“面向对象只是一个语法糖”。以上代码用面向过程的方式来写是这样的：并发

type Integer int

func Integer_Less(a Integer, b Integer) bool {
return a < b
}

func main() {
var a Integer = 1
if Integer_Less(a, 2) {
    fmt.Println(a, "Less 2")
}
}

在Go语言中，面向对象的神秘面纱被剥得一干二净。对比这两段代码：oracle

func (a Integer) Less(b Integer) bool {  // 面向对象
    return a < b
}

func Integer_Less(a Integer, b Integer) bool {  // 面向过程
    return a < b
}

a.Less(2)  // 面向对象
Integer_Less(a, 2)  // 面向过程

你能够看出，面向对象只是换了一种语法形式来表达。在Go语言中没有隐藏的this指针。这句话的含义是：

第一，方法施加的目标（也就是“对象”）显式传递，没有被隐藏起来。
第二，方法施加的目标（也就是“对象”）不须要非得是指针，也不用非得叫this。

咱们对比Java语言的代码：

class Integer {
    private int val;
    public boolean Less(Integer b) {
        return this.val < b.val;
    }
}

这段Java代码初学者会比较难懂，主要是由于Integer类的Less方法隐藏了第一个参数Integer* this。若是将其翻译成C代码，会更清晰：

struct Integer {
    int val;
};

bool Integer_Less(Integer* this, Integer* b) {
    return this->val < b->val;
}

在Go语言中的面向对象最为直观，也无需支付额外的成本。若是要求对象必须以指针传递，这有时会是个额外成本，由于对象有时很小（好比4个字节），用指针传递并不划算。

只有在你须要修改对象的时候，才必须用指针。它不是Go语言的约束，而是一种天然约束。举个例子：

func (a *Integer) Add(b Integer) {
    *a += b
}

这里为Integer类型增长了Add方法。因为Add方法须要修改对象的值，因此须要用指针引用。调用以下：

func main() {
    var a Integer = 1
a.Add(2)
    fmt.Println("a =", a)
}

运行该程序获得的结果是：a = 3。若是你不用指针：

func (a Integer) Add(b Integer) {
    a += b
}

运行程序获得的结果是：a = 1，也就是维持原来的值。究其缘由，是由于Go和C语言同样，类型都是基于值传递。要想修改变量的值，只能传递指针。

值语义和引用语义

值语义和引用语义的差异在于赋值：

b = a
b.Modify()

若是b的修改不会影响a的值，那么此类型属于值类型。若是会影响a的值，那么此类型是引用类型。

多数Go语言中的类型，包括：

基本类型。如byte、int、bool、float3二、float6四、string等等。
复合类型。如数组(array)、结构体(struct)、指针(pointer)等。

都基于值语义。Go语言中类型的值语义表现得很是完全。咱们这么说是由于数组(array)。若是你学习过C语言，你会知道C语言中的数组(array)比较特别。经过函数传递一个数组的时候基于引用语义，可是在结构体中定义数组变量的时候是值语义（表如今结构体赋值的时候，该数组会被完整地拷贝一份新的副本）。

Go语言中的数组(array)和基本类型没有区别，是很纯粹的值类型。例如：

var a = [3]int{1, 2, 3}
var b = a
b[1]++
fmt.Println(a, b)

程序运行结果：[1 2 3] [1 3 3]。这代表b = a赋值语句是数组内容的完整拷贝。要想表达引用，须要用指针：

var a = [3]int{1, 2, 3}
var b = &a
b[1]++
fmt.Println(a, *b)

程序运行结果：[1 3 3] [1 3 3]。这代表b=&a赋值语句是数组内容的引用。变量b的类型不是[3]int，而是*[3]int类型。

Go语言中有4个类型比较特别，看起来像引用类型：

切片(slice)：指向数组(array)的一个区间。
字典(map)：极其常见的数据结构，提供key-value查询能力。
通道(chan)：执行体(goroutine)间通信设施。
接口(interface)：对一组知足某个契约的类型的抽象。

可是这并不影响咱们将Go语言类型是值语义的本质。咱们一个个来看这些类型：

切片（slice）本质上是range，你能够大体将 []T 表示为：

type slice struct {
    first *T
    last *T
    end *T
}

由于切片（slice）内部是一系列的指针，因此能够改变所指向的数组(array)的元素并不奇怪。slice类型自己的赋值仍然是值语义。

字典(map)本质上是一个字典指针，你能够大体将map[K]V表示为：

type Map_K_V struct {
    ...
}

type map[K]V struct {
    impl *Map_K_V
}

基于指针(pointer)，咱们彻底能够自定义一个引用类型，如：

type IntegerRef struct { impl *int }

通道(chan)和字典(map)相似，本质上是一个指针。为何将他们设计为是引用类型而不是统一的值类型，是由于完整拷贝一个通道(chan)或字典(map)不是常规需求。

一样，接口(interface)具有引用语义，是由于内部维持了两个指针。示意为：

type interface struct {
    data *void
    itab *Itab
}

接口在Go语言中的地位很是重要。关于接口(interface)内部实现细节，后面在高阶话题中，咱们再细细剖析。

结构体(struct)

Go语言的结构体(struct)和其它语言的类(class)有同等的地位。但Go语言放弃了包括继承在内的大量OOP特性，只保留了组合(compose)这个最基础的特性。

组合(compose)甚至不能算OOP的特性。由于连C语言这样的过程式编程语言中，也有结构体(struct)，也有组合(compose)。组合只是造成复合类型的基础。

上面咱们说到，全部的Go语言的类型（指针类型除外）都是能够有本身的方法。在这个背景下，Go语言的结构体(struct)它只是很普通的复合类型，平淡无奇。例如咱们要定义一个矩形类型：

type Rect struct {
    x, y float64
    width, height float64
}

而后咱们定义方法Area来计算矩形的面积：

func (r *Rect) Area() float64 {
    return r.width * r.height
}

初始化

定义了Rect类型后，咱们如何建立并初始化Rect类型的对象实例？有以下方法：

rect1 := new(Rect)
rect2 := &Rect{}
rect3 := &Rect{0, 0, 100, 200}
rect4 := &Rect{width: 100, height: 200}

在Go语言中，未显式进行初始化的变量，都会初始化为该类型的零值（例如对于bool类型的零值为false，对于int类型零值为0，对于string类型零值为空字符串）。

构造函数？不须要。在Go语言中你只须要定义一个普通的函数，只是一般以NewXXX来命名，表示“构造函数”：

func NewRect(x, y, width, height float64) *Rect {
return &Rect{x, y, width, height}
}

这一切很是天然，没有任何突兀之处。

匿名组合

确切地说，Go语言也提供了继承，可是采用了组合的文法，咱们称之为匿名组合：

type Base struct {
    ...
}

func (base *Base) Foo() { ... }
func (base *Base) Bar() { ... }

type Foo struct {
    Base
    ...
}

func (foo *Foo) Bar() {
    foo.Base.Bar()
    ...
}

以上代码定义了一个Base类（实现了Foo、Bar两个成员方法），而后定义了一个Foo类，从 Base“继承”并实现了改写了Bar方法，该方法实现时先调用了基类的Bar方法。

在“派生类”Foo没有改写“基类”Base的成员方法时，相应的方法就被“继承”。例如在上面的例子中，调用foo.Foo() 和调用foo.Base.Foo() 效果一致。

区别于其余语言，Go语言很清晰地告诉你类的内存布局是怎么样的。在Go语言中你还能够为所欲为地修改内存布局，如：

type Foo struct {
...
    Base
}

这段代码从语义上来讲，和上面给例子并没有不一样，但内存布局发生了改变。“基类”Base的数据被放在了“派生类”Foo 的最后。

另外，在Go语言中你还能够以指针方式从一个类“派生”：

type Foo struct {
    *Base
    ...
}

这段Go代码仍然有“派生”的效果，只是Foo建立实例的时候，须要外部提供一个Base类实例的指针。C++ 中其实也有相似的功能，那就是虚基类。可是虚基类是很是让人难以理解的特性，广泛上来讲 C++ 的开发者都会遗忘这个特性。

成员的可访问性

Go语言对关键字的增长很是吝啬。在Go语言中没有private、protected、public这样的关键字。要想某个符号可被其余包(package)访问，须要将该符号定义为大写字母开头。如：

type Rect struct {
    X, Y float64
    Width, Height float64
}

这样，Rect类型的成员变量就所有被public了。成员方法遵循一样的规则，例如：

func (r *Rect) area() float64 {
    return r.Width * r.Height
}

这样，Rect的area方法只能在该类型所在的包(package)内使用。

须要强调的一点是，Go语言中符号的可访问性是包(package)一级的，而不是类一级的。尽管area是Rect的内部方法，可是在同一个包中的其余类型能够访问到它。这样的可访问性控制很粗旷，很特别，可是很是实用。若是Go语言符号的可访问性是类一级的，少不了还要加上friend这样的关键字，以表示两个类是朋友关系，能够访问其中的私有成员。

接口(interface)

Rob Pike曾经说，若是只能选择一个Go语言的特性移植到其余语言中，他会选择接口。

接口(interface)在Go语言有着相当重要的地位。若是说goroutine和channel 是支撑起Go语言的并发模型的基石，让Go语言在现在集群化与多核化的时代，成为一道极为亮丽的风景；那么接口(interface)是Go语言整个类型系统(type system)的基石，让Go语言在基础编程哲学的探索上，达到史无先例的高度。

我曾在多个场合说，Go语言在编程哲学上是变革派，而不是改良派。这不是由于Go语言有 goroutine和channel，而更重要的是由于Go语言的类型系统，由于Go语言的接口。由于有接口，才让Go语言的编程哲学变得完美。

Go 语言的接口(interface)不仅仅只是接口。

为何这么说？让咱们细细道来。

其余语言(C++/Java/C#)的接口

Go语言的接口，并非你以前在其余语言(C++/Java/C#等)中接触到的接口。

在Go语言以前的接口(interface)，主要做为不一样组件之间的契约存在。对契约的实现是强制的，你必须声明你的确实现了该接口。为了实现一个接口，你须要从该接口继承：

interface IFoo {
    void Bar();
}

class Foo implements IFoo { // Java 文法
    ...
}

class Foo : public IFoo { // C++ 文法
...
}

IFoo* foo = new Foo;

哪怕另外存在一个如出一辙的接口，只是名字不一样叫IFoo2（名字同样可是在不一样的名字空间下，也是名字不一样），上面的类Foo只实现了IFoo，但没有实现IFoo2。

这类接口(interface)，咱们称之为侵入式的接口。“侵入式”的主要表如今于实现类须要明确声明本身实现了某个接口。

这种强制性的接口继承，是面向对象编程（OOP）思想发展过程当中的一个重大失误。我之因此这样讲，是由于它从根本上是违背事物的因果关系的。

让咱们从契约的造成过程谈起。设想咱们如今要实现一个简单搜索引擎（SE）。该搜索引擎须要依赖两个模块，一个是哈希表（HT），一个是HTML分析器（HtmlParser）。

搜索引擎的实现者认为，SE对哈希表（HT）的依赖是肯定性的，因此他不并认为须要在SE和HT之间定义接口，而是直接import（或者include）的方式使用了HT；而模块SE对HtmlParser的依赖是不肯定的，将来可能须要有WordParser、PdfParser等模块来替代HtmlParser，以达到不一样的业务要求。为此，他定义了SE和HtmlParser之间的接口，在模块SE中经过接口调用方式间接引用模块HtmlParser。

应当注意到，接口(interface)的需求方是搜索引擎（SE）。只有SE才知道接口应该定义成什么样子才比更为合理。可是接口的实现方是HtmlParser。基于模块设计的单向依赖原则，模块HtmlParser实现自身的业务时，不该该关心某个具体使用方的要求。HtmlParser在实现的时候，甚至还不知道将来有一天SE会用上它。要求模块HtmlParser知道全部它的需求方的须要的接口，并提早声明实现了这些接口是不合理的。一样的道理发生在搜索引擎（SE）本身身上。SE并不可以预计将来会有哪些需求方须要用到本身，而且实现他们所要求的接口。

这个问题在标准库的提供来讲，变得更加突出。好比咱们实现了File类（这里咱们用Go语言的文法来描述要实现的方法，请忽略文法上的细节），它有这些方法：

Read(buf []byte) (n int, err error)
Write(buf []byte) (n int, err error)
Seek(off int64, whence int) (pos int64, err error)
Close() error

那么，究竟是应该定义一个IFile接口，仍是应该定义一系列的IReader, IWriter, ISeeker, ICloser接口，而后让File从他们继承好呢？脱离了实际的用户场景，讨论这两个设计哪一个更好并没有意义。问题在于，实现File类的时候，我怎么知道外部会如何用它呢？

正由于这种不合理的设计，使得Java、C# 的类库每一个类实现的时候都须要纠结：

问题1：我提供哪些接口好呢？
问题2：若是两个类实现了相同的接口，应该把接口放到哪一个包好呢？

非侵入式接口

在Go语言中，一个类只须要实现了接口要求的全部函数，那么咱们就说这个类实现了该接口。例如：

type File struct {
    ...
}

func (f *File) Read(buf []byte) (n int, err error)
func (f *File) Write(buf []byte) (n int, err error)
func (f *File) Seek(off int64, whence int) (pos int64, err error)
func (f *File) Close() error

这里咱们定义了一个File类，并实现有Read，Write，Seek，Close等方法。设想咱们有以下接口：

type IFile interface {
    Read(buf []byte) (n int, err error)
    Write(buf []byte) (n int, err error)
    Seek(off int64, whence int) (pos int64, err error)
    Close() error
}

type IReader interface {
    Read(buf []byte) (n int, err error)
}

type IWriter interface {
    Write(buf []byte) (n int, err error)
}

type ICloser interface {
    Close() error
}

尽管File类并无从这些接口继承，甚至能够不知道这些接口的存在，可是File类实现了这些接口，能够进行赋值：

var file1 IFile = new(File)
var file2 IReader = new(File)
var file3 IWriter = new(File)
var file4 ICloser = new(File)

Go语言的非侵入式接口，看似只是作了很小的文法调整，但实则影响深远。

其一，Go语言的标准库，不再须要绘制类库的继承树图。你必定见过很多C++、Java、C# 类库的继承树图。这里给个Java继承树图：

http://docs.oracle.com/javase/1.4.2/docs/api/overview-tree.html

在Go中，类的继承树并没有意义。你只须要知道这个类实现了哪些方法，每一个方法是啥含义就足够了。

其二，实现类的时候，只须要关心本身应该提供哪些方法。不用再纠结接口须要拆得多细才合理。接口是由使用方按需定义，而不用事前规划。

其三，不用为了实现一个接口而import一个包，目的仅仅是引用其中的某个interface的定义，这是不被推荐的。由于多引用一个外部的package，就意味着更多的耦合。接口由使用方按自身需求来定义，使用方无需关心是否有其余模块定义过相似的接口。

接口赋值

接口(interface)的赋值在Go语言中分为以下2种状况讨论：

将对象实例赋值给接口
将接口赋值给另外一个接口

先讨论将某种类型的对象实例赋值给接口。这要求该对象实例实现了接口要求的全部方法。例如，在以前咱们有实做过一个Integer类型，以下：

type Integer int

func (a Integer) Less(b Integer) bool {
    return a < b
}

func (a *Integer) Add(b Integer) {
    *a += b
}

相应地，咱们定义接口LessAdder，以下：

type LessAdder interface {
    Less(b Integer) bool
    Add(b Integer)
}

如今有个问题：假设咱们定义一个Integer类型的对象实例，怎么其赋值给LessAdder接口呢？应该用下面的语句(1)，仍是语句(2)呢？

var a Integer = 1
var b LessAdder = &a     ... (1)
var b LessAdder = a      ... (2)

答案是应该用语句(1)。缘由在于，Go语言能够根据

func (a Integer) Less(b Integer) bool

这个函数自动生成一个新的Less方法：

func (a *Integer) Less(b Integer) bool {
    return (*a).Less(b)
}

这样，类型 *Integer就既存在Less方法，也存在Add方法，知足LessAdder接口。而从另外一方面来讲，根据

func (a *Integer) Add(b Integer)

这个函数没法自动生成

func (a Integer) Add(b Integer) {
    (&a).Add(b)
}

由于 (&a).Add改变的只是函数参数a，对外部实际要操做的对象并没有影响，这不符合用户的预期。故此，Go语言不会自动为其生成该函数。所以，类型Integer只存在Less方法，缺乏Add方法，不知足LessAdder接口，故此上面的语句(2)不能赋值。

为了进一步证实以上的推理，咱们不妨再定义一个Lesser接口，以下：

type Lesser interface {
    Less(b Integer) bool
}

而后咱们定义一个Integer类型的对象实例，将其赋值给Lesser接口：

var a Integer = 1
var b1 Lesser = &a     ... (1)
var b2 Lesser = a      ... (2)

正如如咱们所料的那样，语句(1)和语句(2)都可以编译经过。

咱们再来讨论另外一种情形：将接口赋值给另外一个接口。在Go语言中，只要两个接口拥有相同的方法列表（次序不一样没关系），那么他们就是等同的，能够相互赋值。例如：

package one

type ReadWriter interface {
    Read(buf []byte) (n int, err error)
    Write(buf []byte) (n int, err error)
}

package two

type IStream interface {
    Write(buf []byte) (n int, err error)
    Read(buf []byte) (n int, err error)
}

这里咱们定义了两个接口，一个叫 one.ReadWriter，一个叫 two.IStream。二者都定义了Read、Write方法，只是定义的次序相反。one.ReadWriter先定义了Read再定义Write，而two.IStream反之。

在Go语言中，这两个接口实际上并没有区别。由于：

任何实现了one.ReadWriter接口的类，均实现了two.IStream。
任何one.ReadWriter接口对象可赋值给two.IStream，反之亦然。
在任何地方使用one.ReadWriter接口，和使用two.IStream并没有差别。

如下这些代码可编译经过：

var file1 two.IStream = new(File)
var file2 one.ReadWriter = file1
var file3 two.IStream = file2

接口赋并不要求两个接口必须等价。若是接口A方法列表是接口B方法列表的子集，那么接口B能够赋值给接口A。例如假设咱们有Writer接口：

type Writer interface {
    Write(buf []byte) (n int, err error)
}

咱们能够将上面的one.ReadWriter、two.IStream接口的实例赋值给Writer接口：

var file1 two.IStream = new(File)
var file4 Writer = file1

可是反过来并不成立：

var file1 Writer = new(File)
var file5 two.IStream = file1 // 编译不能经过！

这段代码没法编译经过。缘由是显然的：file1并无Read方法。

接口查询

有办法让上面Writer接口转换为two.IStream接口么？有。那就是咱们即将讨论的接口查询语法。代码以下：

var file1 Writer = ...
if file5, ok := file1.(two.IStream); ok {
    ...
}

这个if语句的含义是：file1接口指向的对象实例是否实现了two.IStream接口呢？若是实现了，则... 接口查询是否成功，要在运行期才可以肯定。它不像接口赋值，编译器只须要经过静态类型检查便可判断赋值是否可行。

在Windows下作过开发的人，一般都接触过COM，知道COM也有一个接口查询(QueryInterface)。是的，Go语言的接口查询和COM的接口查询(QueryInterface)很是相似，均可以经过对象（组件）的某个接口来查询对象实现的其余接口。固然Go语言的接口查询优雅不少。在Go语言中，对象是否知足某个接口、经过某个接口查询其余接口，这一切都是彻底自动完成的。

让语言内置接口查询，这是一件很是了不得的事情。在COM中实现QueryInterface的过程很是繁复，但QueryInterface是COM体系的根本。COM书籍对QueryInterface的介绍，每每从相似下面这样一段问话开始，它在Go语言中一样适用：

> 你会飞吗？ // IFly
> 不会。
> 你会游泳吗？ // ISwim
> 会。
> 你会叫么？ // IShout
> 会。
> ...

随着问题深刻，你从开始对对象（组件）一无所知（在Go语言中是interface{}，在COM中是IUnknown），到逐步有了深刻的了解。

可是你最终可以彻底了解对象么？COM说不能，你只能无限逼近，但永远不能彻底了解一个组件。Go语言说：你能。

在Go语言中，你能够向接口询问，它指向的对象是不是某个类型，例子以下：

var file1 Writer = ...
if file6, ok := file1.(*File); ok {
    ...
}

这个if语句的含义是：file1接口指向的对象实例是不是 *File 类型呢？若是是的，则...

你能够认为查询接口所指向的对象是不是某个类型，只是接口查询的一个特例。接口是对一组类型的公共特性的抽象。因此查询接口与查询具体类型的区别，比如是下面这两句问话的区别：

> 你是医生吗？
> 是。
> 你是某某某？
> 是。

第一句问话查的是一个群体，是查询接口；而第二句问话已经到了具体的个体，是查询具体类型。

在C++/Java/C# 等语言中，也有一些相似的动态查询能力，好比查询一个对象的类型是不是继承自某个类型（基类查询），或者是否实现了某个接口（接口派生查询）。可是他们的动态查询与Go的动态查询很不同。

> 你是医生吗？

对于这个问题，基类查询看起来像是在这么问：“你老爸是医生吗？”；接口派生查询则看起来像是这么问：“你有医师执照吗？”；在Go语言中，则是先肯定知足什么样的条件才是医生，好比技能要求有哪些，而后才是按条件一一拷问，确认是否知足条件，只要知足了你就是医生，不关心你是否有医师执照，或者是小国执照不被天朝认可。

类型查询

在Go语言中，你还能够更加直接了当地询问接口指向的对象实例的类型。例如：

var v1 interface{} = ...

switch v := v1.(type) {
    case int: // 如今v的类型是int
    case string: // 如今v的类型是string
    ...
}

就像现实生活中物种多得数不清同样，语言中的类型也多的数不清。因此类型查询并不常常被使用。它更多看起来是个补充，须要配合接口查询使用。例如：

type Stringer interface {
    String() string
}

func Println(args ...interface{}) {
    for _, arg := range args { 
    switch v := v1.(type) {
    case int: // 如今v的类型是int
    case string: // 如今v的类型是string
    default:
        if v, ok := arg.(Stringer); ok { // 如今v的类型是Stringer
            val := v.String()
            ...
        } else {
            ...
        }
    }
}

Go语言标准库的Println固然比这个例子要复杂不少。咱们这里摘取其中的关键部分进行分析。对于内置类型，Println采用穷举法来，针对每一个类型分别转换为字符串进行打印。对于更通常的状况，首先肯定该类型是否实现了String()方法，若是实现了则用String()方法转换为字符串进行打印。不然，Println利用反射(reflect)遍历对象的全部成员变量进行打印。

是的，利用反射(reflect)也能够进行类型查询，详细可参阅reflect.TypeOf方法相关文档。在后文高阶话题中咱们也会探讨有关“反射(reflect)”的话题。

Any类型

因为Go语言中任何对象实例都知足空接口interface{}，故此interface{}看起来像是能够指向任何对象的Any类型。以下：

var v1 interface{} = 1      // 将int类型赋值给interface{}
var v2 interface{} = "abc"    // 将string类型赋值给interface{}
var v3 interface{} = &v2    // 将*interface{}类型赋值给interface{}
var v4 interface{} = struct{ X int }{1}
var v5 interface{} = &struct{ X int }{1}

当一个函数能够接受任意的对象实例时，咱们会将其声明为interface{}。最典型的例子是标准库fmt中PrintXXX系列的函数。例如：

func Printf(fmt string, args ...interface{})
func Println(args ...interface{})
...

前面咱们已经简单分析过Println的实现，也已经展现过interface{}的用法。总结来讲，interface{} 相似于COM中的IUnknown，咱们刚开始对其一无所知，但咱们能够经过接口查询和类型查询逐步了解它。

总结

咱们说，Go 语言的接口(interface)不仅仅只是接口。在其余语言中，接口仅仅做为组件间的契约存在。从这个层面讲，Go语言接口的重要突破是，其接口是非侵入式的，把其余语言接口的反作用消除了。

可是Go语言的接口不只仅是契约做用。它是Go语言类型系统(type system)的纲。这表如今：

接口查询：经过接口你能够查询接口所指向的对象是否实现了另外的接口。
类型查询：经过接口你能够查询接口所指向的对象的具体类型。
Any类型：在Go语言中interface{}可指向任意的对象实例。