go struct 静态函数_Go语言学习笔记（四）结构体struct 接口Interface 反射reflect...
加 Golang學(xué)習(xí) QQ群共同學(xué)習(xí)進(jìn)步成家立業(yè)工作 ^-^ 群號：96933959
結(jié)構(gòu)體struct
struct 用來自定義復(fù)雜數(shù)據(jù)結(jié)構(gòu)，可以包含多個(gè)字段(屬性)，可以嵌套；
go中的struct類型理解為類，可以定義方法，和函數(shù)定義有些許區(qū)別；
struct類型是值類型。
struct定義
type User struct{
NamestringAge int32
messstring}
varuser Uservar user1 *User = &User{}var user2 *User = new(User)
struct使用
下面示例中user1和user2為指針類型，訪問的時(shí)候編譯器會自動把 user1.Name 轉(zhuǎn)為?(*user1).Name
func main() {varuser User
user.Name= "nick"user.Age= 18user.mess= "lover"
var user1 *User = &User{
Name:"dawn",
Age:21,
}
fmt.Println(*user1) //{dawn 21 }
fmt.Println(user1.Name, (*user1).Name) //dawn dawn
var user2 *User = new(User)
user2.Name= "suoning"user2.Age= 18fmt.Println(user2)//&{suoning 18 }
fmt.Println(user2.Name, (*user2).Name) //suoning suoning
}
構(gòu)造函數(shù)
golang中的struct沒有構(gòu)造函數(shù)，可以偽造一個(gè)
type User struct{
NamestringAge int32
messstring}
func NewUser(namestring, age int32, mess string) *User {return &User{Name:name,Age:age,mess:mess}
}
func main() {//user := new(User)
user := NewUser("suoning", 18, "lover")
fmt.Println(user, user.mess, user.Name, user.Age)
}
內(nèi)存布局
struct中的所有字段在內(nèi)存是連續(xù)的，布局如下：
varuser User
user.Name= "nick"user.Age= 18user.mess= "lover"fmt.Println(user)//{nick 18 lover}
fmt.Printf("Name:%p\n", &user.Name) //Name:0xc420016180
fmt.Printf("Age: %p\n", &user.Age) //Age: 0xc420016190
fmt.Printf("mess:%p\n", &user.mess) //mess:0xc420016198 8字節(jié)為內(nèi)存對齊
方法
方法是作用在特定類型的變量上，因此自定義類型，都可以有方法，而不僅僅是struct。
方法的訪問控制也是通過大小寫控制。
init函數(shù)是通過傳入指針實(shí)現(xiàn)，這樣改變struct字段值，因?yàn)槭侵殿愋汀?/p>
type User struct{
NamestringAgeintsexstring}
func (this *User) init(name string, age int, sex string) {this.Name =namethis.Age =agethis.sex =sex
}
func (this User) GetName() string{return this.Name
}
func main() {varuser User
user.init("nick", 18, "man")//(&user).init("nick", 18, "man")
name :=user.GetName()
fmt.Println(name)
}
匿名字段
如果有沖突的，?則最外的優(yōu)先
type User struct{
Name stirng
Ageint}
type Loverstruct{
User
sex time.TimeintAgeint}
繼承 & 多重繼承
一個(gè)結(jié)構(gòu)體繼承多個(gè)結(jié)構(gòu)體，訪問通過點(diǎn)。繼承字段以及方法。
可以起別名，如下面 u1(user1)，訪問?user.u1.Age。
如果繼承的結(jié)構(gòu)體都擁有同一個(gè)字段，通過user.name訪問就會報(bào)錯(cuò)，必須通過user.user1.name來訪問。
type user1 struct{
namestringAgeint}
type user2struct{
namestringageintsex time.Time
}
type Userstruct{
u1 user1//別名
user2
NamestringAgeint}
func main() {varuser User
user.Name= "nick"user.u1.Age= 18fmt.Println(user)//{{ 18} { 0 {0 0 }} nick 0}
}
tag
在go中，首字母大小寫有特殊的語法含義，小寫包外無法引用。由于需要和其它的系統(tǒng)進(jìn)行數(shù)據(jù)交互，例如轉(zhuǎn)成json格式。這個(gè)時(shí)候如果用屬性名來作為鍵值可能不一定會符合項(xiàng)目要求。tag在轉(zhuǎn)換成其它數(shù)據(jù)格式的時(shí)候，會使用其中特定的字段作為鍵值。
import "encoding/json"type Userstruct{
Namestring `json:"userName"`
Ageint `json:"userAge"`
}
func main() {varuser User
user.Name= "nick"user.Age= 18conJson, _ :=json.Marshal(user)
fmt.Println(string(conJson)) //{"userName":"nick","userAge":0}
}
String()
如果實(shí)現(xiàn)了String()這個(gè)方法，那么fmt默認(rèn)會調(diào)用String()。
type name1 struct{int
string}
func (this *name1) String() string{return fmt.Sprintf("This is String(%s).", this.string)
}
func main() {
n := new(name1)
fmt.Println(n)//This is String().
n.string = "suoning"d := fmt.Sprintf("%s", n) //This is String(suoning).
fmt.Println(d)
}
defer所有錯(cuò)誤
func myE() (str string, err error) {
defer func() {if p := recover(); p !=nil {
str, ok := p.(string)ifok {
err=errors.New(str)
}else{
err= errors.New("panic")
}//debug.PrintStack()
}
}()
panic("this is panic message")return "hello girl", err
}
接口Interface
Interface類型可以定義一組方法，但是這些不需要實(shí)現(xiàn)。并且interface不能包含任何變量。
interface類型默認(rèn)是一個(gè)指針。
Interface定義
type Car interface{
NameGet()stringRun(nint)
Stop()
}
Interface實(shí)現(xiàn)
Golang中的接口，不需要顯示的實(shí)現(xiàn)。只要一個(gè)變量，含有接口類型中的所有方法，那么這個(gè)變量就實(shí)現(xiàn)這個(gè)接口。因此，golang中沒有implement類似的關(guān)鍵字；
如果一個(gè)變量含有了多個(gè)interface類型的方法，那么這個(gè)變量就實(shí)現(xiàn)了多個(gè)接口；如果一個(gè)變量只含有了1個(gè)interface的方部分方法，那么這個(gè)變量沒有實(shí)現(xiàn)這個(gè)接口。
空接口?Interface{}：空接口沒有任何方法，所以所有類型都實(shí)現(xiàn)了空接口。
var a int
var b interface{} //空接口
b = a
多態(tài)
一種事物的多種形態(tài)，都可以按照統(tǒng)一的接口進(jìn)行操作。
栗子：
type Car interface{
NameGet()stringRun(nint)
Stop()
}
type BMWstruct{
Namestring}
func (this *BMW) NameGet() string{return this.Name
}
func (this *BMW) Run(n int) {
fmt.Printf("BMW is running of num is %d \n", n)
}
func (this *BMW) Stop() {
fmt.Printf("BMW is stop \n")
}
type Benzstruct{
Namestring}
func (this *Benz) NameGet() string{return this.Name
}
func (this *Benz) Run(n int) {
fmt.Printf("Benz is running of num is %d \n", n)
}
func (this *Benz) Stop() {
fmt.Printf("Benz is stop \n")
}
func (this *Benz) ChatUp() {
fmt.Printf("ChatUp \n")
}
func main() {varcar Car
fmt.Println(car)//
var bmw BMW = BMW{Name: "寶馬"}
car= &bmw
fmt.Println(car.NameGet())//寶馬
car.Run(1) //BMW is running of num is 1
car.Stop() //BMW is stop
benz := &Benz{Name: "大奔"}
car=benz
fmt.Println(car.NameGet())//大奔
car.Run(2) //Benz is running of num is 2
car.Stop() //Benz is stop//car.ChatUp()//ERROR: car.ChatUp undefined (type Car has no field or method ChatUp)
}
Interface嵌套
一個(gè)接口可以嵌套在另外的接口。
即需要實(shí)現(xiàn)2個(gè)接口的方法。
type Car interface{
NameGet()stringRun(nint)
Stop()
}
type Usedinterface{
Car
Cheap()
}
類型斷言
類型斷言，由于接口是一般類型，不知道具體類型，
如果要轉(zhuǎn)成具體類型，可以采用以下方法進(jìn)行轉(zhuǎn)換：
var t int
var x interface{}
x=t
y= x.(int) //轉(zhuǎn)成int
y, ok = x.(int) //轉(zhuǎn)成int，不報(bào)錯(cuò)
栗子一：
func test(i interface{}) {//n := i.(int)
n, ok := i.(int)if !ok {
fmt.Println("error")return}
n+= 10fmt.Println(n)
}
func main() {var t1 inttest(t1)
}
栗子二：
switch &?type
type Student struct{
Namestring}
func judgmentType(items ...interface{}) {for k, v :=range items {switchv.(type) {case string:
fmt.Printf("string, %d[%v]\n", k, v)case bool:
fmt.Printf("bool, %d[%v]\n", k, v)case int, int32, int64:
fmt.Printf("int, %d[%v]\n", k, v)casefloat32, float64:
fmt.Printf("float, %d[%v]\n", k, v)caseStudent:
fmt.Printf("Student, %d[%v]\n", k, v)case *Student:
fmt.Printf("Student, %d[%p]\n", k, v)
}
}
}
func main() {
stu1 := &Student{Name: "nick"}
judgmentType(1, 2.2, "learing", stu1)
}
栗子三：
判斷一個(gè)變量是否實(shí)現(xiàn)了指定接口
type Stringer interface{
String()string}
type Mystructinterface{
}
type Mystruct2struct{
}
func (this *Mystruct2) String() string{return ""}
func main() {varv Mystructvarv2 Mystruct2
v= &v2if sv, ok :=v.(Stringer); ok {
fmt.Printf("%v implements String(): %s\n", sv.String());
}
}
反射 reflect
reflect包實(shí)現(xiàn)了運(yùn)行時(shí)反射，允許程序操作任意類型的對象。
典型用法是用靜態(tài)類型interface{}保存一個(gè)值，
通過調(diào)用TypeOf獲取其動態(tài)類型信息，該函數(shù)返回一個(gè)Type類型值。
調(diào)用ValueOf函數(shù)返回一個(gè)Value類型值，該值代表運(yùn)行時(shí)的數(shù)據(jù)。
func TypeOf(i interface{}) Type
TypeOf返回接口中保存的值的類型，TypeOf(nil)會返回nil。
func ValueOf(i interface{}) Value
ValueOf返回一個(gè)初始化為i接口保管的具體值的Value，ValueOf(nil)返回Value零值。
reflect.Value.Kind
獲取變量的類別，返回一個(gè)常量
const(
Invalid Kind=iota
Bool
Int
Int8
Int16
Int32
Int64
Uint
Uint8
Uint16
Uint32
Uint64
Uintptr
Float32
Float64
Complex64
Complex128
Array
Chan
Func
Interface
Map
Ptr
Slice
String
Struct
UnsafePointer
)
reflect.Value.Kind()方法返回的常量
reflect.Value.Interface()
轉(zhuǎn)換成interface{}類型
【變量Interface{}Reflect.Value】
獲取變量的值：
reflect.ValueOf(x).Int()
reflect.ValueOf(x).Float()
reflect.ValueOf(x).String()
reflect.ValueOf(x).Bool()
通過反射的來改變變量的值
reflect.Value.SetXX相關(guān)方法，比如:
reflect.Value.SetInt()，設(shè)置整數(shù)
reflect.Value.SetFloat()，設(shè)置浮點(diǎn)數(shù)
reflect.Value.SetString()，設(shè)置字符串
栗子一
import "reflect"func main() {var x float64 = 5.21fmt.Println("type:", reflect.TypeOf(x)) //type: float64
v :=reflect.ValueOf(x)
fmt.Println("value:", v) //value: 5.21
fmt.Println("type:", v.Type()) //type: float64
fmt.Println("kind:", v.Kind()) //kind: float64
fmt.Println("value:", v.Float()) //value: 5.21
fmt.Println(v.Interface())//5.21
fmt.Printf("value is %1.1e\n", v.Interface()) //value is 5.2e+00
y :=v.Interface().(float64)
fmt.Println(y)//5.21
}
栗子二(修改值)
SetXX(x) 因?yàn)閭鬟f的是 x 的值的副本，所以SetXX不能夠改 x，改動 x 必須向函數(shù)傳遞 x 的指針，SetXX(&x) 。
//錯(cuò)誤代碼！！！//panic: reflect: reflect.Value.SetFloat using unaddressable value
func main() {vara float64
fv := reflect.ValueOf(&a)
fv.SetFloat(520.00)
fmt.Printf("%v\n", a)
}
//正確的，傳指針
func main() {vara2 float64
fv2 := reflect.ValueOf(&a2)
fv2.Elem().SetFloat(520.00)
fmt.Printf("%v\n", a2) //520
}
反射操作結(jié)構(gòu)體
reflect.Value.NumField()獲取結(jié)構(gòu)體中字段的個(gè)數(shù)
reflect.Value.Method(n).Call(nil)來調(diào)用結(jié)構(gòu)體中的方法
栗子一(通過反射操作結(jié)構(gòu)體)
import "reflect"type NotknownTypestruct{
S1stringS2stringS3string}
func (n NotknownType) String()string{return n.S1 + "&" + n.S2 + "&" +n.S3
}var secret interface{} = NotknownType{"Go", "C", "Python"}
func main() {
value :=reflect.ValueOf(secret)
fmt.Println(value)//Go & C & Python
typ :=reflect.TypeOf(secret)
fmt.Println(typ)//main.NotknownType
knd :=value.Kind()
fmt.Println(knd)//struct
for i := 0; i < value.NumField(); i++{
fmt.Printf("Field %d: %v\n", i, value.Field(i))
}
results := value.Method(0).Call(nil)
fmt.Println(results)//[Go & C & Python]
}
栗子二(通過反射修改結(jié)構(gòu)體)
import "reflect"type Tstruct{
AintBstring}
func main() {
t := T{18, "nick"}
s := reflect.ValueOf(&t).Elem()
typeOfT :=s.Type()for i := 0; i < s.NumField(); i++{
f :=s.Field(i)
fmt.Printf("%d: %s %s = %v\n", i,
typeOfT.Field(i).Name, f.Type(), f.Interface())
}
s.Field(0).SetInt(25)
s.Field(1).SetString("nicky")
fmt.Println(t)
}/*輸出：
0: A int = 18
1: B string = nick
{25 nicky}*/
import "reflect"type teststruct{
S1strings2strings3string}var s interface{} = &test{
S1:"s1",
s2:"s2",
s3:"s3",
}
func main() {
val :=reflect.ValueOf(s)
fmt.Println(val)//&{s1 s2 s3}
fmt.Println(val.Elem()) //{s1 s2 s3}
fmt.Println(val.Elem().Field(0)) //s1
val.Elem().Field(0).SetString("hehe") //S1大寫
}
栗子三(struct tag 內(nèi)部實(shí)現(xiàn))
package main
import ("fmt"
"reflect")
type Userstruct{
Namestring `json:"user_name"`
}
func main() {varuser User
userType :=reflect.TypeOf(user)
jsonString := userType.Field(0).Tag.Get("json")
fmt.Println(jsonString)//user_name
}
總結(jié)
以上是生活随笔為你收集整理的go struct 静态函数_Go语言学习笔记（四）结构体struct 接口Interface 反射reflect...的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： matlaba绘制gps星空图_网络图横
- 下一篇： leetcode 4 --- 寻找两个有