什么是 Interface
在面向对象的世界中，接口的一般定义是“接口定义对象的行为”，即只定义对象的行为，至于对象如何行动则具体实现在对象中。
在 Golang 中，接口是一组方法签名，当一个类型为接口中的所有方法提供定义时，就说实现了该接口。接口指定类型应具有的方法，类型决定如何实现这些方法。
接口的定义和实现
package main
import (
"fmt"
)
//interface definition
type VowelsFinder interface {
FindVowels() []rune
}
type MyString string
//MyString implements VowelsFinder
func (ms MyString) FindVowels() []rune {
var vowels []rune
for _, rune := range ms {
if rune == 'a' || rune == 'e' || rune == 'i' || rune == 'o' || rune == 'u' {
vowels = append(vowels, rune)
}
}
return vowels
}
func main() {
name := MyString("Sam Anderson")
var v VowelsFinder
v = name // possible since MyString implements VowelsFinder
fmt.Printf("Vowels are %c", v.FindVowels())
interface 应用场景
类 java 中的多态
package main
import (
"fmt"
)
// 接口定义
type SalaryCalculator interface {
CalculateSalary() int
}
// 类型1
type Permanent struct {
empId int
basicpay int
pf int
}
// 类型2
type Contract struct {
empId int
basicpay int
}
// Permanent salary 计算实现
func (p Permanent) CalculateSalary() int {
return p.basicpay + p.pf
}
// Contract salary 计算实现
func (c Contract) CalculateSalary() int {
return c.basicpay
}
/*
通过对SalalCalculator切片进行迭代并求和来计算总费用个人雇员的工资
*/
func totalExpense(s []SalaryCalculator) {
expense := 0
for _, v := range s {
expense = expense + v.CalculateSalary()
}
fmt.Printf("Total Expense Per Month $%d", expense)
}
func main() {
pemp1 := Permanent{1, 5000, 20}
pemp2 := Permanent{2, 6000, 30}
cemp1 := Contract{3, 3000}
employees := []SalaryCalculator{pemp1, pemp2, cemp1}
totalExpense(employees)
}
在上述程序片段中，totalExpense 接收一个 interface slice，可以应用于任何实现SalaryCalculator interface 的类型，若我们添加一个新的类型，实现一种新的薪资计算方式，上述代码可以完全不需要修改即可使用。
用于内部表示
可以将接口视为由元组（类型，值）在内部表示。type是接口的基础具体类型，value持有具体类型的值。
type Tester interface {
Test()
}
type MyFloat float64
func (m MyFloat) Test() {
fmt.Println(m)
}
func describe(t Tester) {
fmt.Printf("Interface type %T value %v\n", t, t)
}
func main() {
var t Tester
f := MyFloat(89.7)
t = f // 此处将类型赋值，
describe(t) // 此处的输出为 Interface type main.MyFloat value 89.7
t.Test()
}
空接口
空接口中没有任何方法，表示为 interface{}，由于空接口没有任何方法，因此可以理解为所有类型默认实现了此接口。
func describe(i interface{}) {
fmt.Printf("Type = %T, value = %v\n", i, i)
}
func main() {
s := "Hello World"
describe(s) // Type = string, value = Hello World
i := 55
describe(i) // Type = int, value = 55
strt := struct {
name string
}{
name: "Naveen R",
}
describe(strt) // Type = struct { name string }, value = {Naveen R}
}
类型判定
可以使用语法 i.(T) 获取变量i中T类型的值，以此来判断传入的类型是否正确
s := i.(int) // 获取变量 i 中 int 类型的数据，若 i 不是 int， 则 panic
v, ok := i.(int) // 用这种方式避免 panic
此外，也可以配合 switch 实现类型判断
func findType(i interface{}) {
switch i.(type) {
case string:
fmt.Printf("I am a string and my value is %s\n", i.(string))
case int:
fmt.Printf("I am an int and my value is %d\n", i.(int))
default:
fmt.Printf("Unknown type\n")
}
}
当然，也可以将类型与接口进行比较。如果我们有一个类型，并且该类型实现了一个接口，则可以将该类型与其实现的接口进行比较。
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 findType(i interface{}) {
switch v := i.(type) {
case Describer:
v.Describe()
default:
fmt.Printf("unknown type\n")
}
}
通过嵌入接口，实现继承的功能
type SalaryCalculator interface {
DisplaySalary()
}
type LeaveCalculator interface {
CalculateLeavesLeft() int
}
type EmployeeOperations interface {
SalaryCalculator
LeaveCalculator
}
type Employee struct {
firstName string
lastName string
basicPay int
pf int
totalLeaves int
leavesTaken int
}
// Employee 实现了 DisplaySalary 和 CalculateLeavesLeft 两个接口，也就默认实现了 EmployeeOperations 接口
func (e Employee) DisplaySalary() {
fmt.Printf("%s %s has salary $%d", e.firstName, e.lastName, (e.basicPay + e.pf))
}
func (e Employee) CalculateLeavesLeft() int {
return e.totalLeaves - e.leavesTaken
}
func main() {
e := Employee {
firstName: "Naveen",
lastName: "Ramanathan",
basicPay: 5000,
pf: 200,
totalLeaves: 30,
leavesTaken: 5,
}
// 此处可以说 Employee 实现了 EmployeeOperations接口
var empOp EmployeeOperations = e
empOp.DisplaySalary()
fmt.Println("\nLeaves left =", empOp.CalculateLeavesLeft())
}
接口的 0 值
接口的零值为nil。
nil接口具有其基础值和具体类型（如nil）。
type Describer interface {
Describe()
}
func main() {
var d1 Describer
if d1 == nil {
// 此处输出 d1 is nil and has type value
fmt.Printf("d1 is nil and has type %T value %v\n", d1, d1)
}
}
喜欢的话，访问我的主页吧，请多关照！