GO学习笔记---GO中的Interface详解

在学习Go语言的过程中，有几个核心的概念不容易理解，如函数、interface、map、channel、gorotine、struct、等。今天主要总结一下GO中的interface。

学习过C++的同学都知道C++有面向对象编程，有类，有继承，多态机制，可以减少我们代码的编写量，然后实现功能的复用，但是在go中没有面向对象的概念，但是通过interface也能实现面向对象中的多态机制。

首先说一下interface是什么？

go中的interface是一个类型，而且这个类型中包含的是函数，或者interface（这样就形成了嵌套），简单的说就是函数（或方法）的集合。

那么如何才能实现多态呢？多态在C++中采用的是虚函数，在基类中定义一个虚函数，然后在不同的子类中根据需要实现不同的逻辑，这就是多态。而go中要实现这种机制，需要结合interface和struct两个数据结构【Go语言支持除Interface类型外的任何其它数据类型都可以定义其函数（而并非只有struct才支持函数），只不过实际项目中，函数多定义在struct上而已】，因为任何一个struct只要实现了一个interface中的全部的方法那么就可以说这个struct实现了这个interface，这个结构的变量就可以调用这个interface中的方法了，那么不同的结构都根据自己的需要实现一个interface中的全部方法，那不就是多态了嘛。

so、show me the code！

举两个例子来说明：

1、一个简单易懂的例子：

type USB interface {
	Name() string
	Connector()
}
type phoneConnector struct {
	name string
}
type pcConnector struct{
	name string
	lang string
}

func (p phoneConnector) Name() string{
	return p.name
}

func (p phoneConnector) Connector() {
	fmt.Println(p.name," connect!")
}

func (p pcConnector) Name() string{
	return p.name
}
func (p pcConnector) Connector() {
	fmt.Println(p.name,"---PC---")
}

我们定义了一个接口USB，然后定义了两个struct，phoneConnector和pcConnector，然后根据不同的内容实现自己的内容。

那么我们可以定义一个USB的变量分别指向phoneConnector和pcConnector，然后调用各自的connector方法即可，如下：

func main(){
	var u USB
	u = phoneConnector{"phone"}
	u.Connector()
	Disconnect(u)
	u = pcConnector{"PC","en"}
	u.Connector()
}

输出如下：

phone  connect!
PC ---PC---

这就是多态。

另外还有个问题，就是我们如何识别到底是什么类型的struct呢？毕竟这个USB是个“基类”，我们需要能够确定其“子类”类型，方法很简单，通过强制类型转换然后判断类型是什么“子类”类型就行。如下：

func Disconnect(usb USB){
	if _,ok := usb.(pcConnector);ok{
		fmt.Println("Disconnect pc!")
		return
	}else if _,ok := usb.(phoneConnector);ok{
		fmt.Println("Disconnect phone!")
		return
	}
	fmt.Println("Unknown Devices!")
}

输出如下：

phone  connect!
Disconnect phone!
PC ---PC---
Disconnect pc!

2、一个复用Go系统库sort里面的Sort函数的例子：

package main

import (
	"fmt"
	"sort"
)

type person struct{
	name string
	age int
}

type Byage []person
func (p person) String(){
	fmt.Println(p.name,":",p.age)
}
func (b Byage) Len() int {
	return len(b)
}
func (b Byage) Less(i,j int) bool{
	return b[i].age < b[j].age
}
func (b Byage) Swap(i,j int) {
	b[i] ,b[j] = b[j],b[i]
}

定义了一个person的数组类型Byage，我们想对Byage中的成员根据age来排序，那么我们便“重写”了Sort的三个方法，因为Sort是一个接口，其内部定义了就以上三个方法，见下面Sort的源码：

package sort

// A type, typically a collection, that satisfies sort.Interface can be
// sorted by the routines in this package.  The methods require that the
// elements of the collection be enumerated by an integer index.
type Interface interface {
    // Len is the number of elements in the collection.
    Len() int
    // Less reports whether the element with
    // index i should sort before the element with index j.
    Less(i, j int) bool
    // Swap swaps the elements with indexes i and j.
    Swap(i, j int)
}

...

// Sort sorts data.
// It makes one call to data.Len to determine n, and O(n*log(n)) calls to
// data.Less and data.Swap. The sort is not guaranteed to be stable.
func Sort(data Interface) {
    // Switch to heapsort if depth of 2*ceil(lg(n+1)) is reached.
    n := data.Len()
    maxDepth := 0
    for i := n; i > 0; i >>= 1 {
        maxDepth++
    }
    maxDepth *= 2
    quickSort(data, 0, n, maxDepth)
}

Sort 函数的形参是一个 interface，包含了三个方法：Len()，Less(i,j int)，Swap(i, j int)。使用的时候不管数组的元素类型是什么类型（int, float, string…），只要我们实现了这三个方法就可以使用 Sort 函数，这样就实现了“泛型编程”。

然后我们在main中如下编写：

func main(){
	p := []person{
		{"yxq",28},
		{"lmy",10},
	}
	fmt.Println(p)
	sort.Sort(Byage(p))
	fmt.Println(p)
}

输出如下：

[{yxq 28} {lmy 10}]
[{lmy 10} {yxq 28}]