golang学习笔记（6）--面向接口编程

一、    duck typing

duck typing意思是鸭子类型，我们把具备鸭子的行为等部分特征的一个东西叫做鸭子，这是鸭子类型的解释。其实，在go语言中是采用鸭子类型这种思想来实现接口这种编程方式的，我们把一个类只要实现了某接口的方法，我们就说他是这个接口的实现类。如下：

我们定义了一个接口：

type duck interface {
   Get(s string) string //不用func修饰这个方法
}

下面写一个类：
type TheClass struct {
   S string
}
这个类实现了上面接口中的方法，如下，并不需要声明我们要实现某个接口。
func (tc TheClass) Get(s string) string  {
   return tc.S;
}

实现类前面的类型是属于值类型传递，因为我们的接口里面实际是包了一个类型信息与及指针，所以实现一般采用直接的值传递而不是指针传递，因为一样可以对内容修改。

如上通过go语言的方式来说明了什么是鸭子类型。

二、    go语言中的接口。

上面讲过了接口的实现方式。

type duck interface {
   Get(s string) string
}

之前我们有讲过两种go语言的两种“继承“方式，一种是类似于装饰的叫做组合，在类里面放”父类“，另一种是取别名，当然取别名算不上，他不可以增加成员变量。那么接口可以”继承“吗?嗯，当然可以，如下

type littleDuck interface {
duck
A() string

}

这样应该叫接口的“继承”

刚刚在golang社区看到一篇被喷的文章，下面有个人这样说：“golang的接口是非入侵式的，楼主让非得把（**）接口写入到（**）结构中，真是人才啊“

不是很理解什么意思，难道不能够用接口继承吗？问题先留在这里，以后再解决。

（n分钟过后）

查了下什么叫入侵式与非入侵式，附上自己的理解：入侵式是指要申明接口实现了某一个接口什么的，但是非入侵式就不用，一般的oo语言例如java就是入侵式接口设计，需要说明实现，有层级，但是go语言提倡是非入侵式，相对入侵式可能更灵活一点，不那么多依赖，但是这两种设计都各有优点，什么优点？看完下面的就知道了，接下来用例子来说下自己的理解吧。

à: 

Bird 接口 ： fly(),run();

Chicken 接口 ： run()

Wild 接口 ：fly()

如上3个接口，在入侵式接口设计中，chicken接口与wild接口需要去继承bird接口，因为他们属于这个大类，那么我们创建一个chicken的实现类对象的话，只需要实现chicken，然后wild同理。这样做就是入侵式接口设计的思路。

在java中像这样：

interface Bird{
void run();
void fly();

}
interface Wild extends Bird{
void run();

}
interface Chicken extends Bird{
void fly();

}

如果我们想要创建一个Wild的类型的类那么就需要创建一个，需要给wild写个实现类，一个Chicken类型的类就需要写一个Chicken实现类，Bird就需要写一个Bird的实现类，显然接口的复用性不高。当然这样的类型是相当清晰的。

同样有另外一种写法，这样算是入侵式设计的思想，如下：

interface Run{
void run();

}
interface Fly{
void fly();

}

interface Bird1 extends Run,Fly{}

java的接口继承是支持多继承的

这样的写法是一种组装的思想，这也是oo语言中的入侵式接口设计思路，通过继承的方式组装好，然后去写Bird1的实现类，没什么问题。

再看看非入侵式：go语言推荐使用非入侵式接口设计，在写实现类的时候不需要说明实现哪个接口，也不需要去思考这是哪个接口的实现类，只要实现相应的方法就行，一般推荐这样写：

type chicken interface {
run()

}

type wild interface {
fly()

}
type BirdImpl struct {

}
func (b BirdImpl) run()  {

}
func (b BirdImpl) fly(){

}

如上的方式很灵活，我们直接可以birdImpl创建一个类，然后实现一个方法他就属于某一个类型，不用去组装接口。当然，我们也可以通过实现接口的方式来实现接口，如：

type Bird interface {
run()
fly()

}
type chicken interface {
run()

}
type wild interface {
fly()

}

这样的方式相当于bird实现了两个接口的接口，我要创建实体对象的时候需要再创建一个类：
type BirdImpl struct {}
func (b BirdImpl) run(){}
func (b BirdImpl) fly(){}

这个类从这里看必定就实现了上述的3个接口，这样的写法其实是可以的，但是看起来冗余了许多，我完全可以不需要Bird 或者另外两个接口。Go语言这样的接口设计方式相对更简单、灵活了。当然为了更具解释性，我们可以把wild名改成Fly，chicken改成Run。当然这样的组合方式在go语言使用还是不少，因为通过组合的方式也很方便灵活

那么我们可以这样来设计go语言的接口：

type Bird interface {
run()
fly()

}
type BirdImpl struct {}
func (b BirdImpl) run()  {}
func (b BirdImpl) fly(){}

或者这样：

type Run interface {
run()

}
type Fly interface {
fly()

}
type BirdImpl struct {}
func (b BirdImpl) run()  {}
func (b BirdImpl) fly(){}

这样就是非入侵式接口设计，不在接口使用继承。好像最后总结下爱就这么一句话，不在接口关系中使用继承与及接口实现。

 刚刚留了一个问题，入侵式与非入侵式的比较，从上面也可以看到入侵式接口设计类别层级什么的十分清晰，没有那么多依赖，解释性也比较好。非入侵式呢？相对比较灵活，简单，接口复用率高。（这都是我的理解哈，不代表官方说法）

网上对入侵式与非入侵式的观点很多，以上只是我的理解，而且go语言的源码里面也有很多组合接口的地方，我也很难说，这两个概念就先放一放。

三、               接口的使用。

首先说下接口变量的结构，其内部有两个东西，一个是接口实现者的类型，一个是接口实现者的指针，我们来看一段段代码：

var o A

 o = class.B{}

 fmt.Printf("%T,%p",o,o)

这里的B实现了接口A，T是类型，v是值，可以知道o里面实际含有两个人东西。同时要提下，如果在不同包下进行接口实现，记住大写方法名首字母，这样才是public的。

接下来我们讲下接口的组合，上面讲到接口的组合不被推荐，说法是有问题的，通过后面的学习，接口是可以被组合的，而且在go的源码中还大量被用到，这种组合的方式是很方便的，当然存在的问题也是问题，这个就不去争议了，网上观点不一。

接口的组合上文已经讲过了，这里我们来讲讲interface{}，interface{}代表go语言里面的所有类型，意义和java的Object一样，但是go不是说所有类都继承interface，没有这种说法：

i := [...]interface{}{1,"2",3,"a","v"}

 fmt.Println(i)

如上代码，数组元素可以是任意类型，当然可以作为函数传入值类型的时候，就表示可以传入任意类型。

四、               Go两种常用接口。

a)  stringer

这个接口相当与java的toString()方法，我们只要实现string()string方法，就算是实现了这个接口，直接打印对象的时候自动调用string。

func (b B) String() string {

  return "实现了stringer的B"

}

比如这样写。

b)  reader/writer

file其实是实现了reader与writer两个接口的，一般我们需要reader或者writer实例的时候可以传一个file进去也是一样的 ，这里可以用组合

type file interface{

Reader

Writer

}