2020-10-18Go语言接口

  • 时间:
  • 浏览:
  • 来源:互联网

接口定义

在Golang中接口(interface)是一种类型,一种抽象的类型。接口(interface)是一组函数method的集合,Golang中的接口不能包含任何变量。任何其他类型只要实现了这些method方法就是实现了这个接口。

在Golang中接口的所有方法都没有方法体,接口定义了一个对象的行为规范,只定义规范不实现。接口体现了程序设计的多态和高内聚低耦合的思想。

Golang中每个接口由数个方法组成,接口的定义格式如下:

type 接口名 interface {
    方法名1 (参数列表1) 返回值列表1
    方法名2 (参数列表2) 返回值列表2
}
  • 接口名:使用type关键字声明,命名时已办会在单词后面添加er 例如 Writer、Stringer,接口名最好能突出接口类型含义
  • 方法名:当方法名首字母大写且这个接口类型名首字母也是大写时,这个方法可以被接口所在的包之外的代码访问

举例:

package main

import "fmt"

//定义Usber接口
type Usber interface {
	start()
	stop()
}

//定义Phone接口体
type Phone struct {
	Name string
}

//Phone实现接口方法
func (p Phone) start() {
	fmt.Println(p.Name, "启动")
}

func (p Phone) stop() {
	fmt.Println(p.Name, "关闭")
}

func main() {
	phone := Phone{Name: "华为手机P40"}
	phone.start()
	phone.stop()

	var usber1 Usber
	usber1 = Phone{Name: "苹果手机XMax"}
	usber1.start()
	usber1.stop()

}

空接口

Golang 中的接口可以不定义任何方法,没有定义方法的接口就是空接口。空接口标识没有任何约束,因此任何类型变量都可以实现空接口,空接口在实际项目中用的是非常多的,用空接口可以表示任意数据类型。

例如:

package main

import "fmt"

//定义空接口
type EmptyA interface {
}

func main() {
	var a EmptyA
	a = "你好 Golang"
	fmt.Println(a)
}

同时golang中空接口也可以直接当做类型来使用,可以表示任意类型。相当于Java中的Object类型

	var b interface{}
	b = 20
	fmt.Println(b)
	b = true
	fmt.Println(b)
	b = 3.1415926
	fmt.Println(b)

空接口可以作为函数的参数,使用空接口可以接收任意类型的函数参数

package main

import "fmt"


func show( i interface{})   {
	fmt.Println(i)
}

func main() {
	show("hello world")
}

map的值实现空接口

// 定义一个值为空接口类型
var studentInfo = make(map[string]interface{})
studentInfo["userName"] = "张三"
studentInfo["age"] = 15
studentInfo["isWork"] = true

slice切片实现空接口

 

// 定义一个空接口类型的切片
var slice = make([]interface{}, 4, 4)
slice[0] = "张三"
slice[1] = 1
slice[2] = true

类型断言

一个接口的值是由一个具体类型和具体类型的值两部分组成。这两部分分别成为接口的动态类型和动态值。如果我们想要判断接口中值的类型,那么这时候就可以使用类型断言,语法如下:

x.(T)

//X:表示类型为interface{}的变量
//T:表示断言x可能是的类型

该语法返回两个参数,第一个参数是 x 转化为 T类型后的变量,第二个是布尔值,true 标识断言成功,反之失败

示例:

	var inter interface{}
	inter = "weizhouck"
	value, isString := inter.(string)
	fmt.Println(value, isString)

	Print(100)
	Print("100")
	Print(100.12)

func Print(x interface{}) {
	if _, isString := x.(string); isString {
		fmt.Println("传入参数是string类型")
	} else if _, isInt := x.(int); isInt {
		fmt.Println("传入参数是int类型")
	} else {
		fmt.Println("传入其它类型")
	}
}

func Print2(x interface{})  {
	switch x.(type) {
	case int:
		fmt.Println("int类型")
	case string:
		fmt.Println("string类型")
	case bool:
		fmt.Println("bool类型")
	default:
		fmt.Println("其它类型")
	}
}

结构体实现多个接口

实现多个接口的话,可以同事使用两个接口进行结构体接受

// 定义一个Animal的接口,Animal中定义了两个方法,分别是setName 和 getName,分别让DOg结构体和Cat结构体实现
type Animal interface {
	SetName(string)
}

// 接口2
type Animal2 interface {
	GetName()string
}

type Dog struct {
	Name string
}

func (d *Dog) SetName(name string)  {
	d.Name = name
}
func (d Dog)GetName()string {
	return d.Name
}

func main() {
	var dog = &Dog{
		"小黑",
	}
	// 同时实现两个接口
	var d1 Animal = dog
	var d2 Animal2 = dog
	d1.SetName("小鸡")
	fmt.Println(d2.GetName())
}

接口嵌套

在 Golang 中,允许接口嵌套接口,我们首先创建一个 Animal1和 Animal2,然后使用 Animal接收刚刚的两个接口

package main

import "fmt"

type Animal1 interface {
	SetName(string)
}

type Animal2 interface {
	GetName() string
}

type Animal interface {
	Animal1
	Animal2
}
type Dog struct {
	Name string
}

func (d *Dog) SetName(name string) {
	d.Name = name
}
func (d Dog) GetName() string {
	return d.Name
}
func main() {
	var dog = &Dog{
		"小黑",
	}
	fmt.Println(dog.GetName())

	// 同时实现两个接口
	var d Animal = dog
	d.SetName("小鸡")
	fmt.Println(d.GetName())
}

Golang中空接口和类型断言

// golang中空接口和类型断言
	var userInfo = make(map[string]interface{})
	userInfo["userName"] = "zhangsan"
	userInfo["age"] = 10
	userInfo["hobby"] = []string{"吃饭", "睡觉"}
	fmt.Println(userInfo["userName"])
	fmt.Println(userInfo["age"])
	fmt.Println(userInfo["hobby"])
	// 但是我们空接口如何获取数组中的值?发现 userInfo["hobby"][0]  这样做不行
	// fmt.Println(userInfo["hobby"][0])
	// 这个时候我们就可以使用类型断言了
	hobbyValue,ok := userInfo["hobby"].([]string)
	if ok {
		fmt.Println(hobbyValue[0])
	}

通过类型断言返回来的值,我们就能够直接通过角标获取了。

本文链接http://element-ui.cn/article/show-220220.aspx