接口
接着上次的继续讲接口,先回顾一下接口的用法:
package main
import "fmt"
// 定义接口
type Car interface {
GetName() string
Run()
}
// 定义结构体
type Tesla struct {
Name string
}
// 实现接口的GetName()方法
func (t *Tesla) GetName() string {
return t.Name
}
// 实现接口的Run()方法
func (t *Tesla) Run() {
fmt.Printf("%s is running\n", t.Name)
}
func main() {
var c Car
var t Tesla = Tesla{"Tesla Model S"}
c = &t // 上面是用指针*Tesla实现了接口的方法,这里要传地址
/* 或者在定义的时候,就定义结构体指针
var t *Tesla = &Tesla{"Tesla Model X"}
c = t
*/
fmt.Println(c.GetName())
c.Run()
}
强调一下:interface 类型默认是一个指针
空接口
没有定义任何方法的接口,就是空接口:
type Empty interface{} // 定义了一个接口类型 Empty,里面没有任何方法
var e1 Empty // e1 就是一个空接口
var e2 interface{} // e2 也是空接口,这里跳过了接口类型的定义,在定义接口的同时把接口类型一起做了
由于空接口里没有定义任何方法,任何类型都实现了空接口。也就是空接口可以被任何类型实现,空接口能够容纳任何类型。
package main
import "fmt"
func main(){
var e interface{} // 定义一个空接口
var n int
e = n // n可以给e赋值,因为n实现了e。这样接口就能存储它具体的实现类
//n = e // 反过来就不行,
fmt.Printf("%T %T\n", n, e) // 通过接口也能获取到它的实现类
}
之前一直使用的 fmt.Println()
,什么类型都可以往里传。这个函数接收的参数是这样的:
func(a ...interface{}) (n int, err error)
这里单看参数类型,就是空接口,任何类型都实现了空接口,所以任何类型都能作为参数。 类型转换 空接口也是个类型,类型转换的用法是一样的,不要遇到了大括号就看不懂了:
var i int // 定义一个int类型
j := int32(i) // 转成int32
k := interface{}(i) // 转成空接口类型
对自定义结构体排序
排序使用 sort 包。包里提供了 Sort 方法可以对接口进行排序。
func Sort(data Interface)
Sort 对 data 进行排序。它调用一次 data.Len 来决定排序的长度 n,调用 data.Less 和 data.Swap 的开销为 O(n*log(n))。此排序为不稳定排序。 这里是对接口进行排序,所以传入的 data 参数需要实现接口里的方法,接口的定义如下:
type Interface interface {
// Len is the number of elements in the collection.
// Len 为集合内元素的总数
Len() int
// Less reports whether the element with
// index i should sort before the element with index j.
//
// Less 返回索引为 i 的元素是否应排在索引为 j 的元素之前。
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
// Swap 交换索引为 i 和 j 的元素
Swap(i, j int)
}
所以要对你的自定义结构体进行排序,首先定义一个该结构体类型的切片类型,然后实现上面的3个方法。之后就可以插入数据然后进行排序了:
package main
import (
"fmt"
"sort"
)
// 自定义的结构体
type Animal struct {
Type string
Weitht int
}
// 新定义一个切片的类型,下面对这个类型实现interface要求的3个方法
// 直接用 []Animal Go不认,这里应该是起了个别名
type AnimalSlice []Animal
// 对自定义的切片类型实现Sort的接口要求的3个方法
func (a AnimalSlice) Len() int {
return len(a)
}
func (a AnimalSlice) Less(i, j int) bool {
return a[i].Weitht < a[j].Weitht
}
func (a AnimalSlice) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
func main() {
var tiger Animal = Animal{"Tiger", 200}
var dog Animal = Animal{"Dog", 20}
var cat Animal = Animal{"Cat", 15}
var elephant Animal = Animal{"Elephant", 4000}
// 这里的切片要用自定义的类型,别名被认为是两个不同的类型,只有这个实现了接口的方法
var data AnimalSlice
data = append(data, tiger)
data = append(data, dog)
data = append(data, cat)
data = append(data, elephant)
fmt.Println(data)
sort.Sort(data)
fmt.Println(data)
}
接口嵌套
一个接口可以嵌套另外的接口:
type ReadWrite interface {
Read(b Buffer) bool
Write(b Buffer) bool
}
type Lock interface {
Lock()
Unlock
}
type File interface {
ReadWrite
Lock
Close
}
嵌套的用法类似结构体的继承。这样如果已经有了一些接口,只要把这些接口组合一下,就又产生了一些新的接口了,不用去重复定义。 再来写个例子,主要是熟悉对接口编程的思路,顺便用到了接口的嵌套:
package main
import "fmt"
// 定义一个接口
type Reader interface {
Read()
}
// 再定义一个接口
type Writer interface {
Write(s string)
}
// 定义第三个接口,嵌套上面的两个接口
type ReadWriter interface {
Reader
Writer
}
// 定义一个结构体
type file struct {
content string
}
func (f *file) Read(){
fmt.Println(f.content)
}
func (f *file) Write(s string){
f.content = s
fmt.Println("写入数据:", s)
}
// 这个函数是对接口进行操作,上面的file类型实现了接口的所有方法
func CheckChange(rw ReadWriter, s string) {
rw.Read()
rw.Write(s)
rw.Read()
}
func main() {
var f file = file{"Hello"}
CheckChange(&f, "How are you")
}
上面写的 CheckChange() 方法,只有是实现了 ReadWriter 这个接口的任何类型,都可以用这个函数来调用。
类型断言
类型断言,由于接口是一般类型,不知道具体的类型。 之前的例子里的函数,定义的入参是接口。而实际传入的是某个实现了接口类型的具体类型。比如上面的例子 CheckChange() 方法接收的参数主要是实现了 ReadWriter 接口的任何类型都可以。可以是例子里的自定义类型 file。也可以是别的类型比如再自定义一个 message。这样在函数接收参数后,是不知道这个参数的具体类型的。有些场景,你需要知道这个接口指向的具体类型是什么。 可以把接口类型转成具体类型,如果要转成具体类型,可以采用以下方法进行转换:
package main
import "fmt"
func main() {
var i int = 10 // 这个是int
var j interface{} // 这个是空接口
fmt.Printf("%T %v\n", j, j) // 还没给j赋值,现在j只是一个空指针,默认类型和默认值都是nil
j = i // 任何类型都可以给空接口赋值,如果i是参数传入的,现在并不知道i的类型
fmt.Printf("%T %v\n", j, j) // 可以打印查看现在的j的类型和值都是和i一样的,但是代码层面还是不知道具体类型
res := j.(int) // 转成int类型,如果不是int类型会报错
//res := j.(int32) // 转成int32,由于类型不对,会报错
fmt.Printf("%T %v\n", res, res)
}
上面在 res := j.(int)
这句做类型转换之前,打印 j 的类型的时候已经看到类型是 int 了,但是其实 j 的类型在代码层面还不知道。需要执行这句类型转换把类型转成 int 。下面的函数接收空接口,但是内部要做加法,只有将参数转成数值类型后,才能做加法:
func add(a interface{}){
b := a.(int) // 只有做了类型转换,才能做下面的加法
b++
c := a
fmt.Printf("%T %v\n", c, c) // 虽然能打印出类型,但是代码层面这个的类型还是interface{}
//c++ // 这句还不能执行,现在c的类型是interface{},只有数值类型能做加法
}
上面是不带检查的,如果类型转换不成功,会报错。下面是带检查的类型断言:
package main
import "fmt"
type Num struct {
n int
}
func main() {
var i Num = Num{1}
var j interface{}
j = i
res, ok := j.(int) // 带检查的类型断言
fmt.Println(res, ok) // ok是false,类型不对,res的值就是转换类型的默认值
var k interface{}
k = i
res2, ok := k.(Num) // 这次类型是对的
fmt.Println(res2, ok) // ok是true
}
判断类型
除了类型断言,还有这个方法可以判断类型。 下面的函数可以判断传入参数的类型:
package main
import "fmt"
func classifier(items ...interface{}) {
for i, v := range items {
switch v.(type) {
case bool:
fmt.Println("bool", i)
case float64:
fmt.Println("float64", i)
case int:
fmt.Println("int", i)
case nil:
fmt.Println("nil", i)
case string:
fmt.Println("string", i)
default:
fmt.Println("unknow", i)
}
}
}
func main() {
classifier(1, "", nil, 1.234, true, int32(5))
}
/* 执行结果
PS H:\Go\src\go_dev\day6\interface\classifier> go run main.go
int 0
string 1
nil 2
float64 3
bool 4
unknow 5
PS H:\Go\src\go_dev\day6\interface\classifier>
*/
这里用到了 v.(type) ,这个必须与 switch case 联合使用,如果写在 switch 外面,编译器会报错。
判断是否实现了指定接口
语法如下:
v, ok := interface{}(实例).(接口名)
先要把类型转成空接口,然后再判断是否实现了指定的接口。 示例:
package main
import "fmt"
// 定义一个结构体
type Example struct{
Name string
}
// 这是一个接口
type IF1 interface{
Hello()
}
// 这是另一个接口
type IF2 interface{
Hi()
}
// 实现了接口 IF1 的方法
func (e Example) Hello(){
fmt.Println("Hello")
}
func main(){
var e Example = Example{"TEST"} // 这里可以不做初始化的,不初始化也是有默认值的,srting型就是空
v, ok := interface{}(e).(IF1)
fmt.Println(v, ok)
v2, ok := interface{}(e).(IF2)
fmt.Println(v2, ok)
}
/* 执行结果
PS H:\Go\src\go_dev\day6\interface\is_if> go run main.go
{TEST} true
<nil> false
PS H:\Go\src\go_dev\day6\interface\is_if>
*/
接口示例
实现一个通用的链表类 重点要实现尾插法,头插法的当前节点不用移动,始终是头节点就行了。而尾插法要有一个当前节点的指针始终指向最后的一个节点。示例:
// go_dev\day6\interface\link\link\link.go
package link
import (
"fmt"
)
type Link struct{
Data interface{} // 数据是空接口,所以是通用类型
Next *Link
}
// 头插法,p需要传指针,因为方法里需要改变p的值
// 但是p本身也是个指针,所以接收的类型是指针的指针
func (l *Link) AddNodeHead(data interface{}, p **Link){
var node Link
node.Data = data
node.Next = (*p).Next
(*p).Next = &node
}
// 尾插法
func (l *Link) AddNodeTail(data interface{}, p **Link){
var node Link
node.Data = data
(*p).Next = &node
(*p) = &node
}
// 遍历链表的方法,打印当前节点以及之后的所有的节点
func (l *Link) Trans(){
for l != nil {
fmt.Println(*l)
l = l.Next
}
}
// go_dev\day6\interface\link\main\main.go
package main
import (
"../link"
)
func main(){
var intLink link.Link // 别名,后面都用intLink
head := intLink // head是头节点
p := &head // p是指向当前节点的指针,注意结构体是值类型
// 插入节点
for i := 0; i < 10; i++ {
node := intLink
node.Data = i
// 插入节点的方法,需改改变p本真的值,这里就要把p的地址传进去
// 由于p本身已经是个指针了,再传指针的地址,那个变量就是指针的指针
//intLink.AddNodeHead(node, &p) // 头插法
intLink.AddNodeTail(node, &p) // 尾插法
}
head.Trans() // 从头节点遍历链表
}
这个例子用了指针的指针。因为结构体是值类型,指向当前节点的变量p需要是一个指针类型。然而在添加节点的方法里(主要是尾插法),需要改变p的值,将p重新指向新插入的节点。这就要求必须把p的地址传进来,这样就是指针的指针了。 其实也可以不用那么做,不在方法里改变p的值,而是给方法添加一个返回值,返回最新的当前节点。这样就需要在调用方法的时候获取返回值然后赋值给p,就是在方法外改变p的值,这样就可以传p的副本给方法处理了。
实现一个负载均衡的调度算法,支持随机、轮训等算法
// go_dev\day6\interface\balance\balancd\balance.go
// 定义接口、结构体,以及对结构体的封装
package balance
import "fmt"
type Balancer interface {
DoBalance([]*Instance) (*Instance, error)
}
// 封装:里面的字段都是小写,这样外部不可见,就无法查看也无法修改,甚至无法创建
// 在对结构体做什么样的操作,就再写方法来实现
// 这样就可以把这个结构体封装好,只能用提供的方法进行有限的操作
type Instance struct {
host string
port int
}
// 结构体里的字段都是小写,外部不可见,外部调用构造函数创建结构体
func NewInstance(host string, port int) *Instance {
return &Instance{host, port}
}
// 还是因为封装,这里再提供方法可以查询
func (i *Instance) GetHost() string{
return i.host
}
func (i *Instance) GetPort() int{
return i.port
}
func (i *Instance) String() string{
return fmt.Sprintf("%v:%v", i.host, i.port)
}
// go_dev\day6\interface\balance\balancd\random.go
// 随机算法
package balance
import (
"errors"
"math/rand"
"time"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
// 虽然是个空结构体,但是需要一个结构体类型,然后去实现Balancer接口里的方法
type RandomBalance struct{
}
func (b *RandomBalance) DoBalance(objs []*Instance) (obj *Instance, err error) {
if len(objs) == 0 {
err = errors.New("没有传入任何实例")
return
}
l := len(objs)
i := rand.Intn(l)
obj = objs[i]
return
}
// go_dev\day6\interface\balance\balancd\round_robin.go
// 轮训算法
package balance
import (
"errors"
)
type RoundRobinBalance struct{
Index int
}
func (b *RoundRobinBalance) DoBalance(objs []*Instance) (obj *Instance, err error) {
if len(objs) == 0 {
err = errors.New("没有传入任何实例")
return
}
l := len(objs)
if b.Index >= l {
b.Index = 0
}
obj = objs[b.Index]
b.Index = (b.Index + 1) % l
return
}
// go_dev\day6\interface\balance\main\main.go
// 使用和测试上面写的balance包
package main
import (
"../balance"
"fmt"
"os"
"strconv"
)
func main(){
var objs []*balance.Instance
for i := 0; i < 5; i++ {
host := "Host" + strconv.Itoa(i)
port := 80 + i
obj := balance.NewInstance(host, port)
objs = append(objs, obj)
}
var balancer balance.Balancer
var arg = "round"
if len(os.Args) > 1 {
arg = os.Args[1]
}
if arg == "random" {
balancer = &balance.RandomBalance{}
} else if arg == "round" {
balancer = &balance.RoundRobinBalance{}
} else {
arg = "random"
// 不同的参数对应不同的负载均衡算法,生成不同的实例
// 直接再通过实例调用里面的方法,是不需要用到接口的
// 在这里,要用balancer这个变量来接收不同的结构体类型,就需要用到接口了
// 只要实现了接口的里DoBalance()方法,就可以赋值给接口,之后就用接口统一调用这个方法
balancer = &balance.RandomBalance{}
}
fmt.Println("负载均衡算法:", arg)
// 调用10次,检查负载均衡的效果
for i := 0; i < 10; i++{
obj, err := balancer.DoBalance(objs) // 通过接口统一调用方法
if err != nil {
fmt.Println("异常:", err)
continue
}
fmt.Println(obj)
}
}
反射
反射,可以在运行时动态的获取到变量的相关信息。需要 reflect 包:
import "reflect"
基本用法
主要是下面这2个函数:
func TypeOf(i interface{}) Type
: 获取变量的类型,返回 reflect.Type 类型func ValueOf(i interface{}) Value
: 获取变量的值,返回 reflect.Value 类型
package main
import (
"fmt"
"reflect"
)
func test(a interface{}){
t := reflect.TypeOf(a)
fmt.Println(t)
v := reflect.ValueOf(a)
fmt.Println(v)
}
func main(){
n := 100
test(n)
}
/* 执行结果
PS H:\Go\src\go_dev\day6\reflect\beginning> go run main.go
int
100
PS H:\Go\src\go_dev\day6\reflect\beginning>
*/
在 reflect.Value 里提供了很多方法。大多数情况下,都是要先获取到 reflect.Value 类型,然后再调用对应的方法来实现。
获取类别(kind)
类型(type)和类别(kind),原生的类型两个的名字应该是一样了。不过自定义类型比如结构体,type就是我们自定义的名字,而kind就是struct。 要获取kind,首先是用上面的方法获取到 reflect.Value 类型,然后调用 Kind 方法,返回 reflect.Kind 类型:
func (v Value) Kind() Kind
具体用法:
package main
import (
"fmt"
"reflect"
)
type Example struct{} // 自定义结构体,看下类型和类别
func main(){
a1 := 10
t1 := reflect.TypeOf(a1)
v1 := reflect.ValueOf(a1)
k1 := v1.Kind()
fmt.Println(t1, k1) // 原生类型的类别看不出来
a2 := Example{}
t2 := reflect.TypeOf(a2)
v2 := reflect.ValueOf(a2)
k2 := v2.Kind()
fmt.Println(t2, k2) // 自定义结构体的类型是自定义的名字,类别是struct
}
/* 执行结果
PS H:\Go\src\go_dev\day6\reflect\kind> go run main.go
int int
main.Example struct
reflect.Kind string
*/
示例中我们最后看到的是打印输出的效果。上面的两个 Kind() 方法的返回值的类型是 reflect.Kind ,这是包里定义的常量。如果要进行比较的话,这样比较:
k1 == reflect.Struct
k2 == reflect.String
另外,返回的类型并不是字符串类型。返回的是包里定义的常量上面已经讲过了。如果要获取类型的字符串名称,可以用 reflect.Kind 类型的 String() 方法:
func (k Kind) String() string
转成空接口
用法:
func (v Value) Interface() (i interface{})
示例:
package main
import (
"fmt"
"reflect"
)
type Student struct{
Name string
Age int
}
func main(){
var s Student = Student{"Adam", 18}
t := reflect.ValueOf(s)
tif := t.Interface() // 调用Interface()方法,返回空接口类型
// 类型断言,必须要用空接口调用
if stu, ok := tif.(Student); ok{
fmt.Printf("%T %v\n", stu, stu)
}
}
获取、设置变量
通过反射获取变量的值:
func (v Value) Float() float64
func (v Value) Int() int64
func (v Value) Bool() bool
func (v Value) String() string
通过反射设置变量的值:
func (v Value) SetFloat(x float64)
func (v Value) SetInt(x int64)
func (v Value) SetBool(x bool)
func (v Value) SetString(x string)
如果要设置的是一个值类型,那么肯定是要传地址的。但是传地址之后,转成了Value类型后就无法再用星号取到指针指向的内容了。这里提供下面的 Elem() 方法。 取指针指向的值:
func (v Value) Elem() Value
示例:
package main
import (
"fmt"
"reflect"
)
func get(x interface{}){
v := reflect.ValueOf(x)
res := v.Int()
fmt.Printf("%T %v\n", res, res)
}
func set(x interface{}){
v := reflect.ValueOf(x) // x如果是个指针,*x是可以用的
// 但是通过ValueOf()方法获得的v就不是指针了,没法用*v
// 所以有了下面的Elem()方法,效果就是我们想要的*v的效果
v.Elem().SetInt(2) // 先要用Elem获取到指针指向的内容,然后才能Set
}
func main(){
var n int = 1
get(n)
set(&n) // 这里肯定是要地址的
get(n)
}
操作结构体
返回结构体里字段、方法的数量:
func (v Value) NumField() int
func (v Value) NumMethod() int
示例:
package main
import (
"fmt"
"reflect"
)
type Student struct{
Name string
Age int
Score float32
}
func TestStruct(x interface{}){
v := reflect.ValueOf(x)
if k := v.Kind(); k != reflect.Struct {
fmt.Println(v, "不是结构体")
return
}
fmt.Println(v, "是结构体")
numOfField := v.NumField()
fmt.Println("结构体里的字段数量:",numOfField)
numOfMethod := v.NumMethod()
fmt.Println("结构体里的方法数量:",numOfMethod)
}
func main() {
TestStruct(1) // 传个非结构体测试一下效果
var a Student = Student{"Adam", 17, 92.5}
TestStruct(a)
}
获取对应的字段、方法 通过下标获取:
func (v Value) Field(i int) Value
func (v Value) Method(i int) Value
还有通过名字获取:
func (v Value) FieldByName(name string) Value
func (v Value) FieldByNameFunc(match func(string) bool) Value
func (v Value) MethodByName(name string) Value
调用方法: 用上面的方法获取到方法后,再 .Call(nil) 就可以执行了。没有参数的话传 nil 就好了。Call只接收1个参数,把方法需要的所有参数都转成 Value 类型然后放在一个切片里传给 Call 执行。返回值也是切片,里面所有的值都是 Value 类型:
func (v Value) Call(in []Value) []Value
上面2句可以写一行里,比如下面这样,调用第一个方法,没有参数,不要返回值:
v.Method(0).Call(nil)
Type 接口的操作
这里用的是TypeOf() 方法,不要和上面的搞混了。返回值是 reflect.Type 类型,这是一个接口类型:
type Type interface {}
接口里的方法比较多,具体去官网看吧:https://go-zh.org/pkg/reflect/#Type
获取字段的Tag对应的内容
json序列化是用Tag替换字段名的实现,利用的也是这里的反射。
通过接口的 Field(i int) StructField
方法,传入下标获取到的是一个 StructField 结构体:
type StructField struct {
// Name is the field name.
// PkgPath is the package path that qualifies a lower case (unexported)
// field name. It is empty for upper case (exported) field names.
// See http://golang.org/ref/spec#Uniqueness_of_identifiers
Name string
PkgPath string
Type Type // field type
Tag StructTag // field tag string
Offset uintptr // offset within struct, in bytes
Index []int // index sequence for Type.FieldByIndex
Anonymous bool // is an embedded field
}
结构体里有一个字段是 Tag ,类型是 StructTag 。这是一个字符串类型的别名,不过里面实现了一些方法。调用 StructTag 的 Get 方法,传入Tag的key,就能返回Tag里对应的value:
func (tag StructTag) Get(key string) string
完整的代码,抄官网的示例( https://go-zh.org/pkg/reflect/#example_StructTag ):
package main
import (
"fmt"
"reflect"
)
func main() {
type S struct {
F string `species:"gopher" color:"blue"`
}
s := S{}
st := reflect.TypeOf(s) // 注意这里是TypeOf,返回值是 Type 接口
field := st.Field(0) // Type 接口里的方法,返回 StructField 结构体。
// StructField结构体里面的Tag字段是 StructTag 一个 string 类型的别名
// StructTag里实现了Get方法,下面就是调用该方法通过key获取到value
fmt.Println(field.Tag.Get("color"), field.Tag.Get("species"))
}
json序列化操作的时候,就是利用了反射的方法,获取到tag里json这个key对应的value,替换原本的字段名。
课后作业
实现一个图书管理系统v2,增加以下功能:
- 增加用户登录、注册功能
- 增加借书过期的图书界面
- 增加显示热门图书的功能,被借次数最多的Top10
- 增加查看某人的借书记录的功能