golang 切片接口

点击上方蓝色“ Go语言中文网 ”关注，每天一起学 Go

欢迎来到 Golang 系列教程^[1]的第 18 个教程。接口共有两个教程，这是我们接口的第一个教程。

什么是接口？

在面向对象的领域里，接口一般这样定义：接口定义一个对象的行为。接口只指定了对象应该做什么，至于如何实现这个行为(即实现细节)，则由对象本身去确定。

在 Go 语言中，接口就是方法签名(Method Signature)的集合。当一个类型定义了接口中的所有方法，我们称它实现了该接口。这与面向对象编程(OOP)的说法很类似。接口指定了一个类型应该具有的方法，并由该类型决定如何实现这些方法。

WashingMachineCleaning()Drying()Cleaning()Drying()WashingMachine

接口的声明与实现

让我们编写代码，创建一个接口并且实现它。

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())

}

在线运行程序^[2]

VowelsFinderFindVowels() []rune

MyString

MyStringFindVowels() []runeMyStringVowelsFinderimplement

vVowelsFindernameMyStringnamevMyStringVowelFinderv.FindVowels()MyStringFindVowelsSam AndersonVowels are [a e o]

祝贺！你已经创建并实现了你的第一个接口。

接口的实际用途

name.FindVowels()v.FindVowels()

因此，我们现在讨论一下接口的实际应用场景。

我们编写一个简单程序，根据公司员工的个人薪资，计算公司的总支出。为了简单起见，我们假定支出的单位都是美元。

package main

import (
    "fmt"
)

type SalaryCalculator interface {
    CalculateSalary() int
}

type Permanent struct {
    empId    int
    basicpay int
    pf       int
}

type Contract struct {
    empId  int
    basicpay int
}

//salary of permanent employee is sum of basic pay and pf
func (p Permanent) CalculateSalary() int {
    return p.basicpay + p.pf
}

//salary of contract employee is the basic pay alone
func (c Contract) CalculateSalary() int {
    return c.basicpay
}

/*
total expense is calculated by iterating though the SalaryCalculator slice and summing
the salaries of the individual employees
*/
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)

}

在线运行程序^[3]

SalaryCalculatorCalculateSalary() int

PermanentContractPermanentbasicpaypfContractbasicpayCalculateSalaryPermanentContractSalaryCalculator

totalExpenseSalaryCalculator[]SalaryCalculatortotalExpensePermanentContactCalculateSalarytotalExpense

totalExpenseFreelancerFreelancertotalExpensetotalExpenseFreelancerSalaryCalculatortotalExpense

Total Expense Per Month $14050

接口的内部表示

(type, value)typevalue

我们编写一个程序来更好地理解它。

package main

import (
    "fmt"
)

type Test interface {
    Tester()
}

type MyFloat float64

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

func describe(t Test) {
    fmt.Printf("Interface type %T value %v\n", t, t)
}

func main() {
    var t Test
    f := MyFloat(89.7)
    t = f
    describe(t)
    t.Tester()
}

在线运行程序^[4]

TestTester()MyFloatfMyFloattTesttMyFloatt89.7describe

Interface type main.MyFloat value 89.7
89.7

空接口

interface{}

package main

import (
    "fmt"
)

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

func main() {
    s := "Hello World"
    describe(s)
    i := 55
    describe(i)
    strt := struct {
        name string
    }{
        name: "Naveen R",
    }
    describe(strt)
}

在线运行程序^[5]

describe(i interface{})

describestringintstruct

Type = string, value = Hello World
Type = int, value = 55
Type = struct { name string }, value = {Naveen R}

类型断言

类型断言用于提取接口的底层值(Underlying Value)。

i.(T)iT

一段代码胜过千言。下面编写个关于类型断言的程序。

package main

import (
    "fmt"
)

func assert(i interface{}) {
    s := i.(int) //get the underlying int value from i
    fmt.Println(s)
}
func main() {
    var s interface{} = 56
    assert(s)
}

在线运行程序^[6]

sinti.(int)i56

在上面程序中，如果具体类型不是 int，会发生什么呢？接下来看看。

package main

import (
    "fmt"
)

func assert(i interface{}) {
    s := i.(int)
    fmt.Println(s)
}
func main() {
    var s interface{} = "Steven Paul"
    assert(s)
}

在线运行程序^[7]

stringsassertpanic: interface conversion: interface {} is string, not int.

要解决该问题，我们可以使用以下语法：

v, ok := i.(T)

iTvioktrue

iTokfalsevT

package main

import (
    "fmt"
)

func assert(i interface{}) {
    v, ok := i.(int)
    fmt.Println(v, ok)
}
func main() {
    var s interface{} = 56
    assert(s)
    var i interface{} = "Steven Paul"
    assert(i)
}

在线运行程序^[8]

assertSteven Pauliintokfalsev

56 true
0 false

类型选择(Type Switch)

类型选择用于将接口的具体类型与很多 case 语句所指定的类型进行比较。它与一般的 switch 语句类似。唯一的区别在于类型选择指定的是类型，而一般的 switch 指定的是值。

i.(T)Ttype

package main

import (
    "fmt"
)

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")
    }
}
func main() {
    findType("Naveen")
    findType(77)
    findType(89.98)
}

在线运行程序^[9]

switch i.(type)i

I am a string and my value is Naveen
I am an int and my value is 77
Unknown type

89.98float64Unknown type

还可以将一个类型和接口相比较。如果一个类型实现了接口，那么该类型与其实现的接口就可以互相比较。

为了阐明这一点，下面写一个程序。

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 findType(i interface{}) {
    switch v := i.(type) {
    case Describer:
        v.Describe()
    default:
        fmt.Printf("unknown type\n")
    }
}

func main() {
    findType("Naveen")
    p := Person{
        name: "Naveen R",
        age:  25,
    }
    findType(p)
}

在线运行程序^[10]

PersonDescribervDescriberpDescriberfindType(p)Describe()

该程序输出：

unknown type
Naveen R is 25 years old

接口(一)的内容到此结束。在接口(二)中我们还会继续讨论接口。祝您愉快！

上一教程 - 方法

下一教程 - 接口 - II^[11]

推荐阅读

Go 经典入门系列 17：方法

福利我为大家整理了一份从入门到进阶的Go学习资料礼包，包含学习建议：入门看什么，进阶看什么。关注公众号「polarisxu」，回复 ebook 获取；还可以回复「进群」，和数万 Gopher 交流学习。

golang 切片 接口