11. 接口

1. 接口的基本介绍

按顺序，应该讲解多态，但是在讲解多态前，我们需要讲解接口(interface)，因为在Golang中，多态的特性主要是通过接口来体现的。

2. 为什么有接口

 3. 接口快速入门

这样的设计需求在Golang编程中也是大量存在的，一个程序就是一个世界，在现实世界存在的情况下，在程序中也会出现。我们用程序来模拟一下前面的应用场景。

package main
import (
	"fmt"
)

// 声明/定义一个接口
type Usb interface {
	// 声明了两个没有实现的方法
	Start()
	Stop()
    Test() // 如果这个方法没实现则会报错
}


type Phone struct {}

// 让Phone实现Usb接口的方法
func (p Phone) Start() {
	fmt.Println("手机开始工作......")
}

func (p Phone) Stop() {
	fmt.Println("手机停止工作......")
}

type Camera struct {}

// 让Camera实现 Usb接口的方法
func (c Camera) Start() {
	fmt.Println("相机开始工作......")
}

func (c Camera) Stop() {
	fmt.Println("相机停止工作......")
}

type Computer struct {}

// 编写一个方法Working，接收一个Usb接口类型的变量
// 只要实现了Usb接口（所谓实现Usb接口，就是指实现了Usb接口声明的所有方法）
func (c Computer) Working(usb Usb) {
	// usb变量会根据传入参数的实参，来判断到底是Phone，还是Camera
	// 通过usb接口变量来调用Start和Stop方法
	usb.Start()
	usb.Stop()
}

func main() {
	// 测试
	// 先创建结构体变量
	computer := Computer{}
	phone := Phone{}
	camera := Camera{}

	// 关键点
	computer.Working(phone)
	computer.Working(camera)
}

4. 接口概念的说明

interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。到某个自定义类型（比如结构体Phone）要使用的时候，再根据具体情况把这些方法写出来（实现）。

5. 基本语法

6. 小结说明 

1）接口里的所有方法都没有方法体，即接口的方法都是没有实现的方法。接口体现了程序设计的多态和高内聚低偶合的思想。

2）Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就能实现这个接口。因此，Golang中没有implement这样的关键字。

7. 接口使用的应用场景

 8. 注意事项和细节

1）接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量（实例）

package main
import (
	"fmt"
)

// 1）接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量(实例)

type AInterface interface {
	Say()
}

type Stu struct {
	Name string
}

func (stu Stu) Say() {
	fmt.Println("Stu Say")
}

func main() {
	var stu Stu  // 结构体变量，实现了 Say()  实现了 AInterface
	var a AInterface = stu
	a.Say()
}

2）接口中所有的方法都没有方法体，即都是没有实现的方法

3）再Golang中，一个自定义类型需要将某个接口的所有方法都实现，我们说这个自定义类型实现了这个接口

4）一个自定义类型只有实现了某个接口，才能将自定义类型的实例（变量）赋给接口类型

5）只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型

package main
import (
	"fmt"
)

type AInterface interface {
	Say()
}

type integer int

func (i integer) Say() {
	fmt.Println("integer Say i=",i)
}

func main() {
	var i integer = 10
	var a AInterface = i
	a.Say()
}

6）一个自定义类型可以实现多个接口

package main
import (
	"fmt"
)

type AInterface interface {
	Say()
}
type BInterface interface {
	Hello()
}

type Monster struct {

}

func (m Monster) Say() {
	fmt.Println("Monster Say()")
}

func (m Monster) Hello() {
	fmt.Println("Monster Hello()")
}

func main() {
	var monster Monster
	var a AInterface = monster
	var b BInterface = monster
	a.Say()
	b.Hello()
}

7）Golang接口中不能有任何变量

 8）一个接口（比如A接口）可以继承多个别的接口（比如B，C接口），这时如果要实现A接口，也必须将B、C接口的方法全部实现

package main
import (
	_"fmt"
)

// 8）一个接口（比如A接口）可以继承多个别的接口（比如B，C接口），这时如果要实现A接口，也必须将B、C接口的方法也全部实现

type BInterface interface {
	test01()
}

type CInterface interface {
	test02()
}

type AInterface interface {
	BInterface
	CInterface
	test03()
}

type Stu struct {}

func (stu Stu) test01() {}
func (stu Stu) test02() {}
func (stu Stu) test03() {}

func main() {
	var a AInterface
	var stu Stu
	a = stu
	a.test01()
}

9）interface类型默认是一个指针（引用类型），如果没有对interface初始化就使用，那么会输出nil

10）空接口interface{} 没有任何方法，所以所有类型都实现了空接口，即我们可以把任何一个变量赋给空接口。

package main
import (
	"fmt"
)

// 10. 空接口 interface{} 没有任何方法，所以所有类型都实现了空接口，即我们可以把任何一个变量赋给空接口

type T interface {}

type Stu struct {}

func (stu Stu) test01() {}

func main() {
	var t T
	var stu Stu
	t = stu
	fmt.Println(t)
	var t2 interface{} = stu
	var num1 float64 = 8.8
	t2 = num1
	fmt.Println(t2,t)
}