Go基础语法（七）

接口

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

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

示例代码：

package main

import "fmt"

//创建名为 VowelsFinder 的接口
type VowelsFinder interface {
    // 该接口有一个 FindVowels() []rune 的方法
    FindVowels() []rune
}

//创建了一个 MyString 类型
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())

}

上边代码中，我们给接受者类型（Receiver Type） MyString 添加了方法 FindVowels() []rune。此时，我们称 MyString 实现了 VowelsFinder 接口。
这就和其他语言（如 Java）很不同，其他一些语言要求一个类使用 implement 关键字，来显式地声明该类实现了接口，而在 Go 中，并不需要这样。如果一个类型包含了接口中声明的所有方法，那么它就隐式地实现了 Go 接口。

代码中，创建一个类型为 VowelsFinder的变量 v ，name 的类型为 MyString，把 name 赋值给了 v。由于 MyString 实现了 VowelFinder，因此这是合法的。在下一行，v.FindVowels() 调用了 MyString 类型的 FindVowels 方法，打印字符串 Sam Anderson 里所有的元音。该程序输出 Vowels are [a e o]。

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

接口的用途

我们编写一个简单程序，根据公司员工的个人薪资，计算公司的总支出。

公司员工分两种：
一种是长期员工，薪资分为基本工资和绩效
一种是合同员工，薪资只有基本工资

上代码:

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
}

//长期员工的工资：基本工资和绩效的总和
func (p Permanent) CalculateSalary() int {
    return p.basicpay + p.pf
}

//合同员工的工资：基本工资
func (c Contract) CalculateSalary() int {
    return c.basicpay
}

/*
该方法接收一个 SalaryCalculator 接口的切片（[]SalaryCalculator）作为参数
通过调用不同类型对应的 CalculateSalary 方法，totalExpense 可以计算得到支出。
*/
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)

}

解释代码：

1. 声明了一个 SalaryCalculator 接口类型，它只有一个方法 CalculateSalary() int。
2. 定义的结构体：Permanent 和 Contract 长期员工和普通员工。
   方法 CalculateSalary 分别实现了计算长期员工和普通员工的总工资。
3. 由于 Permanent 和 Contract 都声明了CalculateSalary方法，因此默认的它们都实现了 SalaryCalculator 接口。
4. totalExpense 方法体现出了接口的妙用。该方法接收一个 SalaryCalculator 接口的切片（[]SalaryCalculator）作为参数。我们向 totalExpense 方法传递了一个包含 Permanent 和 Contact 类型的切片。通过调用不同类型对应的 CalculateSalary 方法，totalExpense 可以计算得到支出。
5. 这样做最大的优点是：totalExpense 可以扩展新的员工类型，而不需要修改任何代码。假如公司增加了一种新的员工类型 Freelancer，它有着不同的薪资结构。Freelancer只需传递到 totalExpense 的切片参数中，无需 totalExpense 方法本身进行修改。只要 Freelancer 也实现了 SalaryCalculator 接口，totalExpense 就能够实现其功能。

接口的内部表示

可以把接口看作内部的一个元组 (type, value)。 type 是接口底层的具体类型（Concrete Type），而 value 是具体类型的值。

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

代码中，describe 函数打印出了接口的具体类型和值。

空接口

不包含方法的接口称为空接口。
空接口表示为 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)
}

上述代码：
分别给 describe 函数传递了 string、int 和 struct

类型断言

类型断言用于提取接口的底层值
在语法 i.(T) 中，接口 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)
}

s 的具体类型是 int。在第 8 行，我们使用了语法 i.(int) 来提取 i 的底层 int 值。该程序会打印 56。

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

var s interface{} = "Steven Paul"

我们把具体类型为 string 的 s 传递给了 assert 函数，试图从它提取出 int 值。该程序会报错：panic: interface conversion: interface {} is string, not int.。

要解决该问题，我们可以使用以下语法：
v, ok := i.(T)

如果 i 的具体类型是 T，那么 v 赋值为 i 的底层值，而 ok 赋值为 true。
如果 i 的具体类型不是 T，那么 ok 赋值为 false，v 赋值为 T 类型的零值，此时程序不会报错。

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

类型选择（Type Switch）

类型选择的语法类似于类型断言。类型断言的语法是 i.(T)，而对于类型选择，类型 T 由关键字 type 代替

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

switch i.(type) 表示一个类型选择。每个 case 语句都把 i 的具体类型和一个指定类型进行了比较。如果 case 匹配成功，会打印出相应的语句
还可以将一个类型和接口相比较。如果一个类型实现了接口，那么该类型与其实现的接口就可以互相比较。

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