网站首页 返回列表
像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang学习笔记之interface

23-09-14 12:44:17 字节波 394

学习Golang有一段时间了，逐渐理解了为什么说Golang的灵魂在于并发与接口，的确如此，它使Golang在现代化语言以及多核集群化时代的大环境下，成为了一道亮丽的风景，本章节将深度解析Golang的接口（interface）。

### 什么是interface
interface是典型的为面向对象编程而服务的，它将具有行为类似的对象统一起来供开发者调用，可以简单的理解为，许多不同的对象，具有类似的行为时，对象负责具体实现该行为，而接口负责提前抽象出来，统一定义该行为，这就可以形成一种先抽象再实现的编程思想。

### 由浅入深去理解interface

例1：
```go
package main

import (
	"fmt"
)

//定义一个动物接口，接口包含speak方法
type Animal interface {
	Speak() string
}

//再定义一个Cat结构体，并实现speak方法
type Cat struct{}
func (c Cat) Speak() string {
	return "喵!"
}
//再定义一个Dog结构体，并实现speak方法
type Dog struct{}
func (d Dog) Speak() string {
	return "汪!"
}

func Test(params interface{}) {
	fmt.Println(params)
}

func main() {
	animals := []Animal{Cat{}, Dog{}}
	for _, animal := range animals {
		fmt.Println(animal.Speak())
	}
	Test("string")
	Test(123)
	Test(true)
}
```
输出：
```shell
喵!
汪!
string
123
true
```

例1中，可这样理解，首先有两个不同的动物类型cat和dog，他们有着不同的叫声，目的是要让它们分别发出自己的叫声，那么就可以利用先抽象再实现的方式来完成这个任务，叫声虽不同，但同属动物发出声音，首先定义一个动物发声的行为接口，分别由不同类型的动物实现该行为接口，最后在调用时先实例化该动物列表，再循环调用每种动物的发声方法，从而达成目的。另可以看出，当interface{}作为函数形参时，可以接受不同类型的参数。

接着再来一个更容易理解且具有较大实践价值的例子吧。

例2：
```go
package main

import "fmt"

// 薪资计算器接口
type SalaryCalculator interface {
	CalculateSalary() int
}
// 普通挖掘机员工
type Contract struct {
	empId  int
	basicpay int
}
// 有蓝翔技校证的员工
type Permanent struct {
	empId  int
	basicpay int
	jj int // 奖金
}

func (p Permanent) CalculateSalary() int {
	return p.basicpay + p.jj
}

func (c Contract) CalculateSalary() int {
	return c.basicpay
}
// 总开支
func totalExpense(s []SalaryCalculator) {
	expense := 0
	for _, v := range s {
		expense = expense + v.CalculateSalary()
	}
	fmt.Printf("总开支 $%d", expense)
}

func main() {
	pemp1 := Permanent{1,3000,10000}
	pemp2 := Permanent{2, 3000, 20000}
	cemp1 := Contract{3, 3000}
	employees := []SalaryCalculator{pemp1, pemp2, cemp1}
	totalExpense(employees)
}
```
输出：
```shell
总开支 $39000
```

例2虽然复杂了许多，但是interface的美感逐渐展现开来，题目是一家公司有很多员工，员工的级别不同薪资不同，需要每月核算薪资总开支，该如何实现。

### 空接口

例1：
```go
package main

import (
	"fmt"
)

type Test1 interface {
	Tester()
}

type MyFloat float64

func (m MyFloat) Tester() {
	fmt.Println(m)
}

func describe(t Test1) {
	fmt.Printf("Interface类型:%T,值:%v\n", t, t)
}

func main() {
	var t Test1
	f := MyFloat(88.8)
	t = f
	describe(t)
	t.Tester()
}
```
输出：
```shell
Interface类型:main.MyFloat,值:88.8
88.8
```

例2：
```go
package main

import (
	"fmt"
)

func describe1(i interface{}) {
	fmt.Printf("Type:%T,value:%v\n", i, i)
}

func main() {
	// 任何类型的变量传入都可以
	x := "Hello World"
	y := 88
	z := struct {name string}{
		name: "WuYun",
	}
	describe1(x)
	describe1(y)
	describe1(z)
}
```
输出：
```shell
Type:string,value:Hello World
Type:int,value:88
Type:struct { name string },value:{WuYun}
```

### 类型断言
例1：
```go
package main

import(
	"fmt"
)

func assert(i interface{}){
	v, ok:= i.(int)
	fmt.Println(v, ok)
}

func main(){
	var s interface{} = 55
	assert(s)
	var i interface{} = "Steven Paul"
	assert(i)
}
```
输出：
```shell
55 true
0 false
```

### 类型判断

例1：
```go
package main

import (
	"fmt"
)

func findType(i interface{}) {
	switch i.(type) {
	case string:
		fmt.Printf("String: %s\n", i.(string))
	case int:
		fmt.Printf("Int: %d\n", i.(int))
	default:
		fmt.Printf("Unknown type\n")
	}
}
func main() {
	findType("Naveen")
	findType(77)
	findType(89.98)
}
```
输出：
```shell
String: Naveen
Int: 77
Unknown type
```

例2：
```go
package main

import "fmt"

type Describer interface {
	Describe()
}
type Person struct {
	name string
	age  int
}

func (p Person) Describe() {
	fmt.Printf("%s is %d years old", p.name, p.age)
}

func findType1(i interface{}) {
	switch v := i.(type) {
	case Describer:
		v.Describe()
	default:
		fmt.Printf("unknown type\n")
	}
}

func main() {
	findType1("Naveen")
	p := Person{
		name: "Naveen R",
		age:  25,
	}
	findType1(p)
}
```
输出：
```shell
unknown type
Naveen R is 25 years old
```

关键字词[Golang, interface]

分享到：

上一篇：Beego框架第1节——环境与初始

下一篇：Golang学习笔记之匿名函数与闭包

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与