Go-interface基本概念

转载

mob604756e75222 2021-08-11 13:18:00

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 接口名 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()
}