Go语言之Interface(一)

9/25/2018 Go算法

Go语言之Interface(一)什么是interface在面向对象语言中接口是:接口定义了一个对象的行为,但在Go中接口就是方法签名的集合,当一个类型提供了这个接口中的所有的方法,就可以说这个类型实现了这个接口接口的声明和实现package mainimport ( "fmt")// 接口的声明t

# Go语言之Interface(一)

# 什么是interface

在面向对象语言中接口是:接口定义了一个对象的行为,但在Go中接口就是方法签名的集合,当一个类型提供了这个接口中的所有的方法,就可以说这个类型实现了这个接口

# 接口的声明和实现

package main

import (
	"fmt"
)

// 接口的声明
type VowelsFinder interface {
	FindVowels() []rune
}

type MyString string

// 接口的实现
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 Andreson")
	var v VowelsFinder
	v = name
	fmt.Printf("Vowels are %c", v.FindVowels())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
  • 声明一个接口
// 接口的声明
type VowelsFinder interface {
	FindVowels() []rune
}
1
2
3
4
  • 实现接口
type MyString string

// 接口的实现
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
}
1
2
3
4
5
6
7
8
9
10
11
12

# 练习使用接口

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
}

func totalExpense(s []SalaryCalculator) {
	expense := 0
	for _, v := range s {
		expense = expense + v.CalculateSalary()
	}
	fmt.Printf("Totla Expense per Month $%d", expense)
}

func main() {
	pemp1 := Permanent{1, 5000, 20}
	pemp2 := Permanent{2, 5000, 30}
	cemp1 := Contract{3, 3000}

	employes := []SalaryCalculator{pemp1, pemp2, cemp1}
	totalExpense(employes)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 接口的内部表示

接口内部可以看着是一个元组 (type,value),type表示接口的具体类型,value表示这个具体类型的值

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.4)
	t = f
	describe(t)
	t.Tester()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出结果

Interface type main.MyFloat value 89.4
89.4
1
2

# 空接口

如果一个接口没有包含方法,那么这个接口就是一个空接口 interface{},由于空接口中没有方法,所以所有的类型都可以实现空接口

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

func main() {
	s := "Hello,World"
	descrip(s)
	i := 55
	descrip(i)

	strt := struct {
		name string
	}{
		name: "CoderMiner",
	}
	descrip(strt)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果是

Type = string,value = Hello,World
Type = int,value = 55
Type = struct { name string },value = {CoderMiner}
1
2
3

# 类型断言(类型转换)

类型转换的语法 i.(T),把i转换为类型T

如转换为int类型

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

var s1 interface{} = 56
asstert(s1)
1
2
3
4
5
6
7

但如果在类型转换时,如果是不同类型转换会发生什么呢?

string转换为int

func asstert(i interface{}) {
	s := i.(int)
	fmt.Println(s)
}
var s1 interface{} = "hello"
asstert(s1)
1
2
3
4
5
6

输出结果是

panic: interface conversion: interface {} is string, not int
1

会触发panic,类型转换失败,如果要避免出现panic,可以使用下面的方法

v, ok := i.(T)
1

如果能够转换成功,ok的值是true,转换失败就是false

func asstert(i interface{}) {
	s, ok := i.(int)
	fmt.Println(s, ok)
}
var s1 interface{} = "hello"
asstert(s1)
var s2 interface{} = 56
asstert(s2)
1
2
3
4
5
6
7
8

输出结果

0 false
56 true
1
2

# 类型判断

语法是

i.(type) 
1
func FindType(i interface{}) {
	switch i.(type) {
	case string:
		fmt.Printf("this is the string type and the value is %s\n", i.(string))
	case int:
		fmt.Printf("this is the int type and the value is %d\n", i.(int))
	default:
		fmt.Printf("Unknown type\n")
	}
}

FindType("CoderMiner")
FindType(77)
FindType(69.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

更多精彩内容 (opens new window)