go语言中为什么是用接口 golang接口深入理解

转载

互联网小墨风 2023-10-27 00:24:52

文章标签 go语言中为什么是用接口赋值 Test 字符串 文章分类 Go语言后端开发

这篇教程是我们关于接口的两篇教程中的第一篇。

什么是接口？

在面向对象的世界中，接口的一般定义是“接口定义了一个对象的行为”。它仅指出这个对象应该做什么，而实现这个行为的方法（实现细节）则取决于具体的对象。

在Go语言中，接口是一组方法签名。当一个类型实现了接口中所有的方法时，我们就说这个类型实现了这个接口。这和面向对象世界中的概念是非常相似的。接口指定类型应该具有什么方法，类型决定如何实现这些方法。

例如：WashingMachine 是一个具有Cleaning()和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())
}

上述程序第8行创建了一个名字为的VowelsFinder接口类型，这个接口有一个方法：FindVowels() []rune，接下来的一行创建了一个MyString类型。

程序第15行，我们为类型MyString添加了方法FindVowels() []rune。现在我们就可以说类型MyString实现了接口VowelsFinder。这与Java等其他语言非常不同，在Java中，类必须使用implements关键字显式地声明它实现了某个接口。而在go语言中，如果某一个类型包含了某个接口中声明的所有方法，则这个类型隐式的实现了此接口。

上述程序第28行，我们将MyString类型的name赋值给了VowelsFinder类型的v。因为MyString实现了VowelsFinder, 所以这个赋值是可以的。程序的下一行语句执行了v.FindVowels()，这调用了MyString类型的FindVowels方法，并打印出了字符串“Sam Anderson”中所有的元音字符。

这个程序最终的输出为：

【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)
}

上述程序第7行声明了一个接口类型：SalaryCalculator，这个接口只有一个CalculateSalary() int方法

我们的公司里有两种类型的员工，一种是固定员工，另一种是合同制员工，并分别在上述代码的第11行和第17行进行了定义。固定员工的工资是基本工资和pf的总和，而合同工的工资只包含基本工资。在上述代码的23行和28行，我们分别为Permanent和Contract实现了计算工资的CalculateSalary方法。通过实现这个方法，Permanent和Contract现在都实现了SalaryCalculator接口。

36行声明的totalExpense函数，表达了使用接口的美。该方法以SalaryCalculator接口类型的切片作为参数。在49行，我们将一个包含Permanent和Contract类型的切片传递给函数totalExpense。最终在第39行，totalExpense函数通过调用对应类型的CalculateSalary方法来计算费用。

这种方式最大的优点是，我们可以扩展新的员工类型，而不需要对totalExpense函数进行任何修改。假设公司增加了一种新的工资结构不同的Freelancer员工。我们不需要对totalExpense函数进行任何代码更改，就可以将Freelancer类型的变量赋值给slice参数，并传递给totalExpense函数。这个方法将做它应该做的，因为Freelancer也实现了SalaryCalculator接口:)。

这段代码的输出为：

Total Expense Per Month $14050.

接口的内部表示

可以认为接口在内部由一个元组(类型、值)表示。类型是接口的底层具体类型，值保存具体类型的值。

让我们写一个程序来更好的理解上边这句话。

package main

import (
    "fmt"
)

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)
    t.Test()
}

Tester接口有一个Test()方法，而MyFloat类型实现了这个接口。在程序的第24行，我们将MyFloat类型的变量f赋值给Tester类型的变量t。现在t的具体类型是MyFloat，它的只是89.7。17行的describe行数打印出了t的具体类型和值。

这个程序的输出如下：

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

在上述程序的第7行，describe函数的参数是一个空接口，所以我们可以给这个函数传递任何类型的值。

我们分别在程序的第13,15和21行，传递了string，int和struct类型的值给describe函数。

这个程序的输出如下：

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

类型断言

类型断言被用来获取接口的真实的值。

用来获取具体类型为T的接口i的真实值的语法是：i.(T)

一个程序胜过千言万语 😃。让我们写一个类型断言的程序。

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

上述代码12行中s的具体类型是int。我们在第8行使用i.(int)语法来获取i的基础值。这个程序最终输出了56。

如果上述程序的具体类型不是int，会发生什么呢？让我们来看看。

package main

import (
    "fmt"
)

func assert(i interface{}) {
    s := i.(int)
    fmt.Println(s)
}

func main() {
    var s interface{} = "Steven Paul"
    assert(s)
}

在上面的程序中，我们将具体类型string的s传递给assert函数，该函数试图从中提取一个int值。该程序将会panic，panic的消息为：

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

为了解决上边的问题，我们可以使用以下语法：

v, ok := i.(T)

如果i的具体类型是T，则v将获得i的底层真实的值，并且ok将被赋值为true。

如果i的具体类型不是T，ok将被赋值为false，而v将被赋值为类型T的零值，程序也不会panic掉。

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

当字符串“Steven Paul”被传递给assert函数，因为i的具体类型不是int，所以ok将会被赋值为false，v将被赋值为int类型的零值0。

这个程序最终输出如下：

56 true
0 false

类型Switch

类型Switch用于将接口的具体类型与各种case语句中指定的多种类型进行比较。它类似于switch case语句。唯一的区别是，case指定的是类型，而一般的switch语句中case指定的是值。

类型Swith的语法和类型断言很相似。我们把类型断言语法i.(T)中的类型T替换为关键字type，就得到了类型Switch。让我们在下面的程序中看看这是如何工作的。

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

在上述程序的第8行，switch i.(type)语句指定了一个类型Switch。每个case语句都将i的具体类型与特定类型进行比较。如果任何一个case匹配，则打印相应的语句。

这个程序最终输出如下：

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

第20行的89.98是一个float64类型的值，由于它不能匹配任何的case语句，所以在最后一行打印出了：

Unknown 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)
}

在上面的程序中，Person结构实现了Describeer接口。在第19行的case语句中，v与Describer接口类型进行比较。由于p实现了Describer接口，因此满足了第19行的case条件，最终调用了Describe()方法。

这个程序最终输出如下：