Go基础知识（二）

一、面向对象类的表示与封装

package mainimport "fmt"//如果类名首字母大写，表示其他包也能够访问
type Hero struct {//如果说类的属性首字母大写, 表示该属性是对外能够访问的，否则的话只能够类的内部访问Name  stringAd    intlevel int
}/*
func (this Hero) Show() {fmt.Println("Name = ", this.Name)fmt.Println("Ad = ", this.Ad)fmt.Println("Level = ", this.Level)
}func (this Hero) GetName() string {return this.Name
}func (this Hero) SetName(newName string) {//this 是调用该方法的对象的一个副本（拷贝）this.Name = newName
}
*/
func (this *Hero) Show() {fmt.Println("Name = ", this.Name)fmt.Println("Ad = ", this.Ad)fmt.Println("Level = ", this.level)
}func (this *Hero) GetName() string {return this.Name
}func (this *Hero) SetName(newName string) {//this 是调用该方法的对象的一个副本（拷贝）this.Name = newName
}func main() {//创建一个对象hero := Hero{Name: "zhang3", Ad: 100}hero.Show()hero.SetName("li4")hero.Show()
}

二、面向对象继承

package mainimport "fmt"type Human struct {name stringsex  string
}func (this *Human) Eat() {fmt.Println("Human.Eat()...")
}func (this *Human) Walk() {fmt.Println("Human.Walk()...")
}//=================type SuperMan struct {Human //SuperMan类继承了Human类的方法level int
}//重定义父类的方法Eat()
func (this *SuperMan) Eat() {fmt.Println("SuperMan.Eat()...")
}//子类的新方法
func (this *SuperMan) Fly() {fmt.Println("SuperMan.Fly()...")
}func (this *SuperMan) Print() {fmt.Println("name = ", this.name)fmt.Println("sex = ", this.sex)fmt.Println("level = ", this.level)
}func main() {h := Human{"zhang3", "female"}h.Eat()h.Walk()//定义一个子类对象//s := SuperMan{Human{"li4", "female"}, 88}var s SuperMans.name = "li4"s.sex = "male"s.level = 88s.Walk() //父类的方法s.Eat()  //子类的方法s.Fly()  //子类的方法s.Print()
}

三、面向对象多态的实现与基本要素

package mainimport "fmt"//本质是一个指针
type AnimalIF interface {Sleep()GetColor() string //获取动物的颜色GetType() string  //获取动物的种类
}//具体的类
type Cat struct {color string //猫的颜色
}func (this *Cat) Sleep() {fmt.Println("Cat is Sleep")
}func (this *Cat) GetColor() string {return this.color
}func (this *Cat) GetType() string {return "Cat"
}//具体的类
type Dog struct {color string
}func (this *Dog) Sleep() {fmt.Println("Dog is Sleep")
}func (this *Dog) GetColor() string {return this.color
}func (this *Dog) GetType() string {return "Dog"
}func showAnimal(animal AnimalIF) {animal.Sleep() //多态fmt.Println("color = ", animal.GetColor())fmt.Println("kind = ", animal.GetType())
}func main() {var animal AnimalIF //接口的数据类型， 父类指针animal = &Cat{"Green"}animal.Sleep() //调用的就是Cat的Sleep()方法 , 多态的现象animal = &Dog{"Yellow"}animal.Sleep() // 调用Dog的Sleep方法，多态的现象cat := Cat{"Green"}dog := Dog{"Yellow"}showAnimal(&cat)showAnimal(&dog)
}

四、interface空接口万能类型与断言机制

package mainimport "fmt"//interface{}是万能数据类型
func myFunc(arg interface{}) {fmt.Println("myFunc is called...")fmt.Println(arg)//interface{} 改如何区分 此时引用的底层数据类型到底是什么？//给 interface{} 提供 “类型断言” 的机制value, ok := arg.(string)if !ok {fmt.Println("arg is not string type")} else {fmt.Println("arg is string type, value = ", value)fmt.Printf("value type is %T\n", value)}
}type Book struct {auth string
}func main() {book := Book{"Golang"}myFunc(book)myFunc(100)myFunc("abc")myFunc(3.14)
}

五、反射reflect用法机制

5.1 基本用法

package mainimport ("fmt""reflect"
)func reflectNum(arg interface{}) {// 定义一个空接口fmt.Println("type:",reflect.TypeOf(arg)) // 获取接口里的数据类型fmt.Println("value:",reflect.ValueOf(arg)) // 获取接口里的值
}func main() {var num float64 = 1.2345reflectNum(num)
}

5.2 深层次用法

package mainimport ("fmt""reflect"
)type User struct {Id   intName stringAge  int
}func (this User) Call() {fmt.Println("user is called..")fmt.Printf("%v\n", this)
}func doFiledMethod(input interface{}) {// 获取input的typeinputType := reflect.TypeOf(input)fmt.Println("inputType is :", inputType.Name())// 获取input的valueinputValue := reflect.ValueOf(input)fmt.Println("inputValue is :", inputValue)// 通过Type获取input里面的字段// 1.获取interface的reflect.Type,通过Type得到NumFiled，进行遍历// 2.得到每个field，数据类型// 3. 通过field有一个Interface()方法得到对应的valuefor i := 0; i < inputType.NumField(); i++ {field := inputType.Field(i)              // 获取字段value := inputValue.Field(i).Interface() // 获取字段对应的值fmt.Printf("%s:%v = %v\n", field.Name, field.Type, value)}// 通过type获取input里面的方法for i := 0; i < inputType.NumMethod(); i++ {m := inputType.Method(i)fmt.Printf("%s: %v\n", m.Name, m.Type)}
}func main() {user := User{1, "Aceld", 18}doFiledMethod(user)
}

六、反射机制解析结构体标签tag

package mainimport ("fmt""reflect"
)type resume struct {Name string `info:"name" doc:"我的名字"`Sex  string `info:"sex"`
}func findTag(str interface{}) {t := reflect.TypeOf(str).Elem() for i := 0; i < t.NumField(); i++ {taginfo := t.Field(i).Tag.Get("info")tagdoc := t.Field(i).Tag.Get("doc")fmt.Println("info: ", taginfo, " doc: ", tagdoc)}
}func main() {var re resumefindTag(&re)}

七、结构体标签和json的转换

package mainimport ("encoding/json""fmt"
)type Movie struct {Title  string   `json:"title"`Year   int      `json:"year"`Price  int      `json:"rmb"`Actors []string `json:"actors"`
}func main() {movie := Movie{"喜剧之王", 2000, 10, []string{"xingye", "zhangbozhi"}}//编码的过程  结构体---> jsonjsonStr, err := json.Marshal(movie)if err != nil {fmt.Println("json marshal error", err)return}fmt.Printf("jsonStr = %s\n", jsonStr)//解码的过程 jsonstr ---> 结构体//jsonStr = {"title":"喜剧之王","year":2000,"rmb":10,"actors":["xingye","zhangbozhi"]}myMovie := Movie{}err = json.Unmarshal(jsonStr, &myMovie)if err != nil {fmt.Println("json unmarshal error ", err)return}fmt.Printf("%v\n", myMovie)
}

八、字符串分割,替换和截取

package main
import ("fmt""strings"
)
func main() {str := "赵,钱,孙,李,赵"//字符串分割, 使用字符分割str1 := strings.Split(str, ",")fmt.Println(str1[0]) //赵fmt.Println(str1[1]) //钱fmt.Println(str1[2]) //孙fmt.Println(str1[3]) //李fmt.Println(str1[4]) //赵//字符串替换, -1表示全部替换, 0表示不替换, 1表示替换第一个, 2表示替换第二个...str2 := strings.Replace(str, "赵", "钱", -1)fmt.Println(str2) //钱,钱,孙,李,钱//字符串截取, 一个汉字3个字节, 还有一个逗号str3 := str[4 : len(str)-4]fmt.Println(str3) //钱,孙,李
}