【Go基础】面向对象和反射机制
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
文章目录
一、面向对象
1. 面向对象的概念
洗衣服过程剖析
- 给洗衣机里加脏衣服和洗衣粉
- 启动洗衣机
- 洗衣机自动注水然后滚动
- 脏衣服从黑颜色变成白颜色
- 洗衣机自动停止
用面向过程的思想实现代码
// 准备洗衣服
// 输入参数
// powder 洗衣机里放多少洗衣粉
// closes 洗衣机里放多少衣服
// clean 衣服是否是干净的
// 返回值
// 洗衣机是否开启
// 准备洗多少衣服
func prepare(powder int, closes int, clean bool) (bool, int) {
if powder <= 0 || closes <= 0 || clean == true {
return false, 0
}
return true, closes
}
// 开始洗衣服
// 输入参数
// washer_state 洗衣机是否开启
// closes 准备洗多少衣服
// 返回值
// 衣服是否是干净的
// 洗了多少衣服
// 洗衣机是否开启
func wash(washer_state bool, closes int) (bool, int, bool) {
if washer_state == false {
return false, 0, false
} else {
fmt.Println("注水")
fmt.Println("滚动")
fmt.Println("关机")
return true, closes, false
}
}
// 检查最终状态
// 输入参数
// clean 衣服是否是干净的
// closes 洗了多少衣服
// washer_state 洗衣机是否开启
func check(clean bool, closes int, washer_state bool) {
if clean && closes > 0 {
fmt.Printf("洗干净了%d件衣服\n", closes)
if washer_state {
fmt.Println("你忘关洗衣机了")
}
} else {
fmt.Println("洗衣失败")
}
}
// 整个洗衣服的过程
func WashProcedure(powder, closes int) {
washer_state := false
clean := false
washer_state, closes = prepare(powder, closes, clean)
clean, closes, washer_state = wash(washer_state, closes)
check(clean, closes, washer_state)
}
面向过程编程整个过程分为若干步每一步对应一个函数函数之间要传递大量的参数
面向对象编程把大量参数封装到一个结构体里面给结构体赋予方法方法里面去修改结构体的成员变量go语言面向对象的好处打包参数、继承、面向接口编程
// 洗衣机
type Washer struct {
State bool
Powder int
}
// 衣服
type Closes struct {
Clean bool
}
func (washer *Washer) prepare(closes []*Closes) error {
if washer.State == true || washer.Powder <= 0 || len(closes) <= 0 {
return errors.New("请确保在关机的状态下加入适量衣物和洗衣粉")
}
return nil
}
func (washer *Washer) wash(closes []*Closes) error {
if err := washer.prepare(closes); err != nil {
return err
}
fmt.Println("开机")
washer.State = true
// 检查是否有脏衣服
clean := true
for _, ele := range closes {
if ele.Clean == false {
clean = false
break
}
}
if clean {
washer.State = false
return errors.New("所有衣服都是干净的不需要洗")
}
// 开始洗衣服
fmt.Println("注水")
fmt.Println("滚动")
fmt.Println("关机")
washer.State = false
for _, ele := range closes {
ele.Clean = true
}
return nil
}
func (washer *Washer) check(err error, closes []*Closes) {
if err != nil {
fmt.Printf("洗衣失败:%v\n", err)
} else {
fmt.Printf("洗干净了%d件衣服\n", len(closes))
if washer.State == true {
fmt.Println("你忘关洗衣机了")
}
}
}
2. 构造函数
定义User结构体
type User struct {
Name string // ""表示未知
Age int // -1表示未知
Sex byte // 1男2女3未知
}
u := User{}构造一个空的User各字段都取相应数据类型的默认值up := new(User)构造一个空的User并返回其指针
自定义构造函数
func NewDefaultUser() *User {
return &User{
Name: "",
Age: -1,
Sex: 3,
}
}
func NewUser(name string, age int, sex byte) *User {
return &User{
Name: name,
Age: age,
Sex: sex,
}
}
单例模式确保在并发的情况下整个进程里只会创建struct的一个实例
var (
sUser *User
uOnce sync.Once
)
func GetUserInstance() *User {
// 确保即使在并发的情况下下面的3行代码在整个go进程里只会被执行一次
uOnce.Do(func() {
if sUser == nil {
sUser = NewDefaultUser()
}
})
return sUser
}
// 调用GetUserInstance()得到的是同一个User实例
su1 := GetUserInstance()
su2 := GetUserInstance()
// 修改su1会影响su2
3. 继承与重写
通过嵌入匿名结构体变相实现“继承”的功能因为访问匿名成员时可以跳过成员名直接访问它的内部成员
type Plane struct {
color string
}
type Bird struct {
Plane
}
bird := Bird {}
bird.Plane.color
bird.color
重写
func (plane Plane) fly() int {
return 500
}
//重写父类(Plane)的fly方法
func (bird Bird) fly() int {
return bird.Plane.fly()+100 // 调用父类的方法
}
正规来讲Go语言并不支持继承它只是支持组合
type Plane struct {}
type Car struct{}
// Bird组合了Plane和Car的功能
type Bird struct {
Plane
Car
}
4. 泛型
在有泛型之前同样的功能需要为不同的参数类型单独实现一个函数
func add4int(a, b int) int {
return a + b
}
func add4float32(a, b float32) float32 {
return a + b
}
func add4string(a, b string) string {
return a + b
}
使用泛型
type Addable interface{
type int, int8, int16, int32, int64,
uint, uint8, uint16, uint32, uint64, uintptr,
float32, float64, complex64, complex128,string
}
func add[T Addable](a,b T)T{
return a+b
}
在go1.17中泛型默认没有开启如果想用运行时命令行需要加-gcflags=-G=3或者设置环境变量export GOFLAGS=“-gcflags=-G=3”泛型正式版将在go 1.18中发布但是Go语言之父Rob Pike建议不在Go 1.18的标准库中使用泛型
二、反射
1. 反射介绍
反射就是在运行期间不是编译期间探知对象的类型信息和内存结构、更新变量、调用它们的方法
反射的使用场景
- 函数的参数类型是interface{}需要在运行时对原始类型进行判断针对不同的类型采取不同的处理方式。比如json.Marshal(v interface{})
- 在运行时根据某些条件动态决定调用哪个函数比如根据配置文件执行相应的算子函数
Go标准库里的json序列化就使用了反射
type User struct {
Name string
Age int
Sex byte `json:"gender"`
}
user := User{
Name: "钱钟书",
Age: 57,
Sex: 1,
}
json.Marshal(user) // 返回 {"Name":"钱钟书","Age":57,"gender":1}
反射的弊端
- 代码难以阅读难以维护
- 编译期间不能发现类型错误覆盖测试难度很大有些bug需要到线上运行很长时间才能发现可能会造成严重用后果
- 反射性能很差通常比正常代码慢一到两个数量级。在对性能要求很高或大量反复调用的代码块里建议不要使用反射
2. 反射的基础数据类型
reflect.Type用于获取类型相关的信息
type Type interface {
Method(int) Method // 第i个方法
MethodByName(string) (Method, bool) // 根据名称获取方法
NumMethod() int // 方法的个数
Name() string // 获取结构体名称
PkgPath() string // 包路径
Size() uintptr // 占用内存的大小
String() string // 获取字符串表述
Kind() Kind //数据类型
Implements(u Type) bool //判断是否实现了某接口
AssignableTo(u Type) bool // 能否赋给另外一种类型
ConvertibleTo(u Type) bool // 能否转换为另外一种类型
Elem() Type // 解析指针
Field(i int) StructField // 第i个成员
FieldByIndex(index []int) StructField // 根据index路径获取嵌套成员
FieldByName(name string) (StructField, bool) // 根据名称获取成员
FieldByNameFunc(match func(string) bool) (StructField, bool) // 根据匹配函数匹配需要的字段
Len() int // 容器的长度
NumIn() int // 输出参数的个数
NumOut() int // 返回参数的个数
}
通过reflect.Value获取、修改原始数据类型里的值
type Value struct {
// 代表的数据类型
typ *rtype
// 指向原始数据的指针
ptr unsafe.Pointer
}
3. 反射API
3.1 reflect.Type
①如何得到Type
通过TypeOf()得到Type类型
typeI := reflect.TypeOf(1)
typeS := reflect.TypeOf("hello")
fmt.Println(typeI) // int
fmt.Println(typeS) // string
typeUser := reflect.TypeOf(&common.User{})
fmt.Println(typeUser) // *common.User
fmt.Println(typeUser.Kind()) // ptr
fmt.Println(typeUser.Elem().Kind()) // struct
②指针Type转为非指针Type
typeUser := reflect.TypeOf(&common.User{})
typeUser2 := reflect.TypeOf(common.User{})
assert.IsEqual(typeUser.Elem(), typeUser2)
③获取struct成员变量的信息
typeUser := reflect.TypeOf(common.User{}) // 需要用struct的Type不能用指针的Type
fieldNum := typeUser.NumField() // 成员变量的个数
for i := 0; i < fieldNum; i++ {
field := typeUser.Field(i)
fmt.Printf("%d %s offset %d anonymous %t type %s exported %t json tag %s\n", i,
field.Name, // 变量名称
field.Offset, // 相对于结构体首地址的内存偏移量string类型会占据16个字节
field.Anonymous, // 是否为匿名成员
field.Type, // 数据类型reflect.Type类型
field.IsExported(), // 包外是否可见即是否以大写字母开头
field.Tag.Get("json")) // 获取成员变量后面``里面定义的tag
}
fmt.Println()
// 可以通过FieldByName获取Field
if nameField, ok := typeUser.FieldByName("Name"); ok {
fmt.Printf("Name is exported %t\n", nameField.IsExported())
}
// 也可以根据FieldByIndex获取Field
thirdField := typeUser.FieldByIndex([]int{2}) // 参数是个slice因为有struct嵌套的情况
fmt.Printf("third field name %s\n", thirdField.Name)
④获取struct成员方法的信息
typeUser := reflect.TypeOf(common.User{})
methodNum := typeUser.NumMethod() // 成员方法的个数接收者为指针的方法【不】包含在内
for i := 0; i < methodNum; i++ {
method := typeUser.Method(i)
fmt.Printf("method name:%s ,type:%s, exported:%t\n", method.Name, method.Type, method.IsExported())
}
fmt.Println()
typeUser2 := reflect.TypeOf(&common.User{})
methodNum = typeUser2.NumMethod() // 成员方法的个数接收者为指针或值的方法【都】包含在内也就是说值实现的方法指针也实现了反之不成立
for i := 0; i < methodNum; i++ {
method := typeUser2.Method(i)
fmt.Printf("method name:%s ,type:%s, exported:%t\n", method.Name, method.Type, method.IsExported())
}
⑤获取函数的信息
func Add(a, b int) int {
return a + b
}
typeFunc := reflect.TypeOf(Add) // 获取函数类型
fmt.Printf("is function type %t\n", typeFunc.Kind() == reflect.Func)
argInNum := typeFunc.NumIn() // 输入参数的个数
argOutNum := typeFunc.NumOut() // 输出参数的个数
for i := 0; i < argInNum; i++ {
argTyp := typeFunc.In(i)
fmt.Printf("第%d个输入参数的类型%s\n", i, argTyp)
}
for i := 0; i < argOutNum; i++ {
argTyp := typeFunc.Out(i)
fmt.Printf("第%d个输出参数的类型%s\n", i, argTyp)
}
⑥判断类型是否实现了某接口
// 通过reflect.TypeOf((*<interface>)(nil)).Elem()获得接口类型因为People是个接口不能创建实例所以把nil强制转为*common.People类型
typeOfPeople := reflect.TypeOf((*common.People)(nil)).Elem()
fmt.Printf("typeOfPeople kind is interface %t\n", typeOfPeople.Kind() == reflect.Interface)
t1 := reflect.TypeOf(common.User{})
t2 := reflect.TypeOf(&common.User{})
// 如果值类型实现了接口则指针类型也实现了接口反之不成立
fmt.Printf("t1 implements People interface %t\n", t1.Implements(typeOfPeople))
3.2 reflect.Value
①如果获得Value
通过ValueOf()得到Value
iValue := reflect.ValueOf(1)
sValue := reflect.ValueOf("hello")
userPtrValue := reflect.ValueOf(&common.User{
Id: 7,
Name: "Ricky",
Weight: 60,
Height: 1.80,
})
fmt.Println(iValue) // 1
fmt.Println(sValue) // hello
fmt.Println(userPtrValue) // &{7 Ricky 60 1.80}
②Value转为Type
iType := iValue.Type()
sType := sValue.Type()
userType := userPtrValue.Type()
// 在Type和相应Value上调用Kind()结果一样的
fmt.Println(iType.Kind() == reflect.Int, iValue.Kind() == reflect.Int, iType.Kind() == iValue.Kind())
fmt.Println(sType.Kind() == reflect.String, sValue.Kind() == reflect.String, sType.Kind() == sValue.Kind())
fmt.Println(userType.Kind() == reflect.Ptr, userPtrValue.Kind() == reflect.Ptr, userType.Kind() == userPtrValue.Kind())
③指针Value和非指针Value互相转换
userValue := userPtrValue.Elem() // Elem() 指针Value转为非指针Value
fmt.Println(userValue.Kind(), userPtrValue.Kind()) // struct ptr
userPtrValue3 := userValue.Addr() // Addr() 非指针Value转为指针Value
fmt.Println(userValue.Kind(), userPtrValue3.Kind()) // struct ptr
④得到Value对应的原始数据
通过Interface()函数把Value转为interface{}再从interface{}强制类型转换转为原始数据类型或者在Value上直接调用Int()、String()等一步到位
fmt.Printf("origin value iValue is %d %d\n", iValue.Interface().(int), iValue.Int())
fmt.Printf("origin value sValue is %s %s\n", sValue.Interface().(string), sValue.String())
user := userValue.Interface().(common.User)
fmt.Printf("id=%d name=%s weight=%.2f height=%.2f\n", user.Id, user.Name, user.Weight, user.Height)
user2 := userPtrValue.Interface().(*common.User)
fmt.Printf("id=%d name=%s weight=%.2f height=%.2f\n", user2.Id, user2.Name, user2.Weight, user2.Height)
⑤空Value的判断
var i interface{} // 接口没有指向具体的值
v := reflect.ValueOf(i)
fmt.Printf("v持有值 %t, type of v is Invalid %t\n", v.IsValid(), v.Kind() == reflect.Invalid)
var user *common.User = nil
v = reflect.ValueOf(user) // Value指向一个nil
if v.IsValid() {
fmt.Printf("v持有的值是nil %t\n", v.IsNil()) // 调用IsNil()前先确保IsValid()否则会panic
}
var u common.User // 只声明里面的值都是0值
v = reflect.ValueOf(u)
if v.IsValid() {
fmt.Printf("v持有的值是对应类型的0值 %t\n", v.IsZero()) // 调用IsZero()前先确保IsValid()否则会panic
}
⑥通过Value修改原始数据的值
var i int = 10
var s string = "hello"
user := common.User{
Id: 7,
Name: "Ricky",
Weight: 60,
Height: 1.80,
}
valueI := reflect.ValueOf(&i) // 由于go语言所有函数传的都是值所以要想修改原来的值就需要传指针
valueS := reflect.ValueOf(&s)
valueUser := reflect.ValueOf(&user)
valueI.Elem().SetInt(8) // 由于valueI对应的原始对象是指针通过Elem()返回指针指向的对象
valueS.Elem().SetString("golang")
valueUser.Elem().FieldByName("Weight").SetFloat(68.0) // FieldByName()通过Name返回类的成员变量
注意要想修改原始数据的值给ValueOf传的必须是指针而指针Value不能调用Set和FieldByName方法所以得先通过Elem()转为非指针Value
未导出成员的值不能通过反射进行修改
addrValue := valueUser.Elem().FieldByName("addr")
if addrValue.CanSet() {
addrValue.SetString("北京")
} else {
fmt.Println("addr是未导出成员不可Set") // 以小写字母开头的成员相当于是私有成员
}
⑦通过Value修改Slice
users := make([]*common.User, 1, 5) //len=1cap=5
users[0] = &common.User{
Id: 7,
Name: "Ricky",
Weight: 60,
Height: 1.80,
}
sliceValue := reflect.ValueOf(&users) // 准备通过Value修改users所以传users的地址
// 取得slice的长度
if sliceValue.Elem().Len() > 0 {
sliceValue.Elem().Index(0).Elem().FieldByName("Name").SetString("令狐一刀")
fmt.Printf("1st user name change to %s\n", users[0].Name)
}
甚至可以修改slice的cap新的cap必须位于原始的len到cap之间即只能把cap改小
sliceValue.Elem().SetCap(3)
通过把len改大可以实现向slice中追加元素的功能
sliceValue.Elem().SetLen(2)
// 调用reflect.Value的Set()函数修改其底层指向的原始数据
sliceValue.Elem().Index(1).Set(reflect.ValueOf(&common.User{
Id: 8,
Name: "李达",
Weight: 80,
Height: 180,
}))
fmt.Printf("2nd user name %s\n", users[1].Name)
⑧修改map
Value.SetMapIndex()函数往map里添加一个key-value对
Value.MapIndex()函数 根据Key取出对应的map
u1 := &common.User{
Id: 7,
Name: "Ricky",
Weight: 60,
Height: 1.80,
}
u2 := &common.User{
Id: 8,
Name: "Ricky",
Weight: 60,
Height: 1.80,
}
userMap := make(map[int]*common.User, 5)
userMap[u1.Id] = u1
mapValue := reflect.ValueOf(&userMap) // 准备通过Value修改userMap所以传userMap的地址
mapValue.Elem().SetMapIndex(reflect.ValueOf(u2.Id), reflect.ValueOf(u2)) // SetMapIndex 往map里添加一个key-value对
mapValue.Elem().MapIndex(reflect.ValueOf(u1.Id)).Elem().FieldByName("Name").SetString("令狐一刀") // MapIndex 根据Key取出对应的map
for k, user := range userMap {
fmt.Printf("key %d name %s\n", k, user.Name)
}
⑨调用函数
valueFunc := reflect.ValueOf(Add) // 函数也是一种数据类型
typeFunc := reflect.TypeOf(Add)
argNum := typeFunc.NumIn() // 函数输入参数的个数
args := make([]reflect.Value, argNum) // 准备函数的输入参数
for i := 0; i < argNum; i++ {
if typeFunc.In(i).Kind() == reflect.Int {
args[i] = reflect.ValueOf(3) // 给每一个参数都赋3
}
}
sumValue := valueFunc.Call(args) // 返回[]reflect.Value因为go语言的函数返回可能是一个列表
if typeFunc.Out(0).Kind() == reflect.Int {
sum := sumValue[0].Interface().(int) // 从Value转为原始数据类型
fmt.Printf("sum=%d\n", sum)
}
⑩调用成员方法
common.User{
Id: 7,
Name: "Ricky",
Weight: 60,
Height: 1.80,
}
valueUser := reflect.ValueOf(&user) // 必须传指针因为BMI()在定义的时候它是指针的方法
bmiMethod := valueUser.MethodByName("BMI") // MethodByName()通过Name返回类的成员变量
resultValue := bmiMethod.Call([]reflect.Value{}) // 无参数时传一个空的切片
result := resultValue[0].Interface().(float32)
fmt.Printf("bmi=%.2f\n", result)
// Think()在定义的时候用的不是指针valueUser可以用指针也可以不用指针
thinkMethod := valueUser.MethodByName("Think")
thinkMethod.Call([]reflect.Value{})
valueUser2 := reflect.ValueOf(user)
thinkMethod = valueUser2.MethodByName("Think")
thinkMethod.Call([]reflect.Value{})
3.3 创建对象
①创建struct
user :=t := reflect.TypeOf(common.User{})
value := reflect.New(t) // 根据reflect.Type创建一个对象得到该对象的指针再根据指针提到reflect.Value
value.Elem().FieldByName("Id").SetInt(10)
user := value.Interface().(*common.User) // 把反射类型转成go原始数据类型Call([]reflect.Value{})
②创建slice
var slice []common.User
sliceType := reflect.TypeOf(slice)
sliceValue := reflect.MakeSlice(sliceType, 1, 3)
sliceValue.Index(0).Set(reflect.ValueOf(common.User{
Id: 8,
Name: "张三",
Weight: 80,
Height: 180,
}))
users := sliceValue.Interface().([]common.User)
fmt.Printf("1st user name %s\n", users[0].Name)
③创建map
var userMap map[int]*common.User
mapType := reflect.TypeOf(userMap)
// mapValue:=reflect.MakeMap(mapType)
mapValue := reflect.MakeMapWithSize(mapType, 10)
user := &common.User{
Id: 7,
Name: "Ricky",
Weight: 60,
Height: 1.80,
}
key := reflect.ValueOf(user.Id)
mapValue.SetMapIndex(key, reflect.ValueOf(user)) // SetMapIndex 往map里添加一个key-value对
mapValue.MapIndex(key).Elem().FieldByName("Name").SetString("令狐一刀") // MapIndex 根据Key取出对应的map
userMap = mapValue.Interface().(map[int]*common.User)
fmt.Printf("user name %s %s\n", userMap[7].Name, user.Name)
reflect包里除了MakeSlice()和MakeMap()还有MakeChan()和MakeFunc()
4. 自行实现json序列化
所谓序列化即把struct实例转为string比如定义了User和Book两个struct
type User struct {
Name string
Age int
Sex byte `json:"gender"`
}
type Book struct {
ISBN string `json:"isbn"`
Author User `json:"author"`
Keywords []string `json:"kws"`
}
Book的实例序列化后为
{
"isbn": "4243547567",
"author": {
"Name": "钱钟书",
"Age": 57,
"gender": 1
},
"kws": ["爱情", "民国", "留学"]
}
序列化实现思路
- 从内向外、从简单到复杂地考虑序列化问题
- 如果要序列化一个int、float、string很简单
- 如果要序列化一个slice则在第1步的基础上用[]括起来
- 如果要序列化一个structFieldName直接打印出来FieldValue的序列化可以参考第1、2步
- 如果struct内部还嵌套了struct则递归调用第3步
- 通过反射解析struct得到json key和struct FieldName的对应关系
- 如果FieldValue是基本的值类型则通过反射给FieldValue赋值很简单
- 如果FieldValue是slice类型则需要通过反射先创建一个slice再给slice里的每个元素赋值
- 如果FieldValue是是内嵌struct则递归调用反序列化函数给FieldValue赋值
- 如果FieldValue是是内嵌struct指针则需要创建内嵌struct对应的实例申请内存空间再递归调用反序列化函数给FieldValue赋值