实例学习Golang--接口（一、接口的实现）

在Go语言中接口（interface）是一种类型，一种抽象的类型。

每个接口类型由数个方法组成。接口的形式代码如下：

type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}

接口类型名：使用 type 将接口定义为自定义的类型名。

Go语言的接口在命名时，一般会在单词后面添加 er，

如有写操作的接口叫 Writer，

有字符串功能的接口叫 Stringer，

有关闭功能的接口叫 Closer 等。

方法名：当方法名首字母是大写时，且这个接口类型名首字母也是大写时，

这个方法可以被接口所在的包（package）之外的代码访问。

参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以被忽略

type writer interface{
    Write([]byte) error
}

Go语言的每个接口中的方法数量不会很多。Go语言希望通过一个接口精准描述它自己的功能，而通过多个接口的嵌入和组合的方式将简单的接口扩展为复杂的接口。

接口的实现条件

在类型中添加与接口声明一致的方法就可以实现该方法，包括方法中的名称、参数列表、返回参数列表

1， 接口中 定义方法

2， 结构体

3， 结构体的方法中包括所有接口中的方法

（比如 dog类型 赋值给 animal 类型， 如果 dog 的方法没有say() 会报错：

dog does not implement animal (missing say method)）

但是不能少可以多，如果dog 实现了多个方法，只要满足接口中的所有方法就行

基于接口的实现条件，结构体多余的方法，可以用来实现其他接口的方法，就实现了 一个类型实现多个接口

同一个接口，每个结构体都可以对它实现，因为方法都是有特定的接收类型的，这样就实现了 多个类型实现同一接口

 一个类型实现多个接口

package main

import "fmt"

type animal interface {
    say()
    run()
}

type naturer interface {
    nature()
}

type dog struct{}
type cat struct {
    name string
}

func (d dog) say() {
    fmt.Println("汪汪汪")
}

func (d dog) run() {
    fmt.Println("奔跑吧")
}

func (d dog) nature() {
    fmt.Println("lively")
}

func (c cat) say(name string) {
    fmt.Println(name, "say 喵喵喵")
}

func (c cat) run() {
    fmt.Println("嗖嗖嗖")
}

func main() {
    // qiqi 和 shiyi 的调用和interface没有关系
    qiqi := cat{
        name: "qiqi",
    }
    qiqi.say(qiqi.name)

    shiyi := dog{}
    shiyi.run()

    // dogRun 是 animal 的实例，有say() 和 run() 方法
    // qiqi 的方法say中，参数为string，所以qiqi 不可以复制给animal类型
    var dogRun animal
    dogRun = shiyi
    dogRun.run()
    
    // dog 中有三个方法 say run nature
    var dogNaturer naturer
    dogNaturer = shiyi
    dogNaturer.nature()

}

再看一个 多个类型实现同一接口

// Mover 接口
type Mover interface {
    move()
}
// 结构体
type dog struct {
    name string
}

type cat struct {
    name string
}

// dog类型实现Mover接口
func (d dog) move() {
    fmt.Printf(d.name)
}

// cat类型实现Mover接口
func (c cat) move() {
    fmt.Printf(c.name)
}

 接口还可以嵌套组合使用

package main

import "fmt"

// Mover 接口
type Mover interface {
	move()
}

type Runer interface {
	run()
}

// 组合 Mover 和 Runer 接口
type Animal interface {
	Mover
	Runer
}

type dog struct {
	name string
}

// dog类型实现Mover接口
func (d dog) move() {
	fmt.Printf("%s move\n", d.name)
}

func (d dog) run() {
	fmt.Printf("%s run\n", d.name)
}

func main() {
	var wang Animal
	jinmao := dog{
		name: "淑芬",
	}
	wang = jinmao
	wang.run()
	wang.move()

}