接口
接口一般这样定义：接口定义一个对象的行为。
接口只指定了对象应该做什么，至于如何实现这个行为（即实现细节），则由对象本身去确定。
在 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)
}
解释代码：
- 声明了一个 SalaryCalculator 接口类型，它只有一个方法 CalculateSalary() int。
- 定义的结构体：Permanent 和 Contract 长期员工和普通员工。
方法 CalculateSalary 分别实现了计算长期员工和普通员工的总工资。 - 由于 Permanent 和 Contract 都声明了CalculateSalary方法，因此默认的它们都实现了 SalaryCalculator 接口。
- totalExpense 方法体现出了接口的妙用。该方法接收一个 SalaryCalculator 接口的切片（[]SalaryCalculator）作为参数。我们向 totalExpense 方法传递了一个包含 Permanent 和 Contact 类型的切片。通过调用不同类型对应的 CalculateSalary 方法，totalExpense 可以计算得到支出。
- 这样做最大的优点是：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)
}
网友评论