一、 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
}