Go-interface基本概念

1. 基本介绍：

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

例：

package main

import (
	"fmt"
)

type Usb interface {
	//声明两个方法
	Start()
	Stop()
}

type Phone struct {
}

type Camera struct {
}

type Computer struct {
}

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

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

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

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

// Computer working方法，接收一个usb接口类型变量
// 只要是实现了USB接口
// 实现USB接口，就是指实现了USB接口声明的所有方法
func (c Computer) Working(usb Usb) {
	//通过USB接口来调用Start和Stop方法
	usb.Start()
	usb.Stop()
}

func main() {
	fmt.Println("Hello")
	//测试
	//1.创建结构体变量
	computer := Computer{}
	phone := Phone{}
	camera := Camera{}

	//关键点
	//把phone传给接口，接口去调用start、stop
	computer.Working(phone)
	//把camera传给接口，接口去调用start、stop
	computer.Working(camera)
}

2. 基本语法：

定义一个接口：

type Randomer interface {
	// 声明方法
	method1(参数列表)返回值列表
	method2(参数列表)返回值列表
	// ……
}

实现接口所有方法：

func (t 自定义类型）method1(参数列表）返回值列表 {
	//方法实现
}
func (t 自定义类型）method2(参数列表）返回值列表 {
	//方法实现
}

3.小结：

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

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

（3）Go实现接口与方法有关，与接口本身叫什么名字没有特别大的关系。变量需要实现接口所有的方法。

 

4.注意事项和细节

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

package main

import (
	"fmt"
)

type AInterface interface {
	Say()
}

type Stu struct {
	Name string
}

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

func main() {
	var stu Stu //结构体变量，实现了Say()，实现了AInterface
	// 接口本身不能创建实例
	// var a AInterface
	// a.Say()
	var a AInterface = stu
	a.Say() 
}

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

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

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

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

package main

import (
	"fmt"
)

type AInterface interface {
	Say()
}

type interger int

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

func main() {
	// 接口本身不能创建实例
	// var a AInterface
	// a.Say()

	var i interger = 10
	i.Say()
	var b AInterface = i
	b.Say()
}

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

package main

import (
	"fmt"
)

type AInterface interface {
	Say()
}

type BInterface interface {
	Hello()
}

type Monster struct {
}

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

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

func main() {
	// 接口本身不能创建实例
	// var a AInterface
	// a.Say()

	//Monster实现了AInterface 和 BInterface
	var monster Monster
	var a2 AInterface = monster
	var b2 BInterface = monster

	a2.Say()
	b2.Hello()
}

（7）Go接口不能有任何变量。

（8）一个接口可以继承多个别的接口，这时如果要实现这个接口必须实现它继承的所有接口的方法。在低版本的Go编辑器中，一个接口继承其他多个接口时，不允许继承的接口有相同的方法名。比如A接口继承B、C接口，B、C接口的方法名不能一样。高版本的Go编辑器没有相关问题。

package main

import (
	"fmt"
)

type AInterface interface {
	test01()
}

type BInterface interface {
	test02()
}

type CInterface interface {
	AInterface
	BInterface
	test03()
}

type Stu struct {
}

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

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

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

func main() {
	// 接口本身不能创建实例
	// var a AInterface
	// a.Say()

	//Monster实现了AInterface 和 BInterface
	var stu Stu
	var c CInterface = stu

	c.test01()
}

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

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

package main

import (
	"fmt"
)

// 空接口
type Temp interface {
}

type Stu struct {
}

func main() {
	// 接口本身不能创建实例
	// var a AInterface
	// a.Say()

	//Monster实现了AInterface 和 BInterface
	var stu Stu
	var t Temp = stu
	fmt.Println(t)

	var t2 interface{} = stu
	fmt.Println(t2)

	var t3 interface{} 
	var num1 float64 = 8.8
	t3 = num1
	fmt.Println(t3)
}

　　

以上资料来源：https://www.bilibili.com/video/BV1ME411Y71o?p=215&spm_id_from=pageDriver