1 、什么是結構體
GO語言中陣列可以存盤同一型別的資料，但在結構體中我們可以為不同項定義不同的資料型別，結構體是由一系列具有相同型別或不同型別的資料構成的資料集合，
2、什么是實體化?
- Go結構體的定義只是一種記憶體布局的描述,只有當結構體實體化時,才會真正分配記憶體，因此必須在定義結構體并實體化后才能使用結構體實體化就是根據結構體定義的格式創建一份與格式一致的內存區域，
- 結構體實體之間的記憶體是完全獨立的，
package mainimport "fmt"func main() { //實體化方式一 var stu1 Student fmt.Printf("stu1=%T,%v,%q \n", stu1, stu1, stu1) stu1.name = "zs" stu1.age = 12 stu1.sex = 1 fmt.Printf("stu1=%T,%v,%q \n", stu1, stu1, stu1) //實體化方式二 stu2 := Student{} stu2.name = "David" stu2.age = 33 stu2.sex = 1 fmt.Printf("stu2=%T,%v,%q \n", stu2, stu2, stu2) //實體化方式三 stu3 := Student{ name: "Josh", age: 28, sex: 1, } fmt.Printf("stu3=%T,%v,%q \n", stu3, stu3, stu3) //實體化四 stu4 := Student{"Ruby", 30, 0} fmt.Printf("stu3=%T,%v,%q \n", stu4, stu4, stu4) //實體化五 //使用內置函式new()對結構體進行實體化,結構體實體化后形成指標型別的結構體 //·new內置函式會分配記憶體，第一個引數是型別,而不是值,回傳的值是指向該型別新分配的零值的指標，該函式用于創建某個型別的指標， stu5 := new(Student) (*stu5).name = "Running" (*stu5).age = 31 stu5.sex = 0 //語法糖的方式 fmt.Printf("stu3=%T,%v,%q \n", stu5, stu5, stu5) //stu3=*main.Student,&{Running 31 0},&{"Running" '\x1f' '\x00'}}//結構體的定義type Student struct { name string age int sex int8}View Code
語法糖的概念( Syntactic sugar)
- 語法糖,也譯為糖衣語法,是由英國計算機科學家彼得·約翰·蘭達( PeterJ.Landin)發明的一個術語,指計算機語言中添加的某種語法,這種語法對語言的功能并沒有影響,但是更方便程式員使用，
- 通常來說使用語法糖能夠增加程式的可讀性,從而減少程式代碼岀錯的機會
- 結構體和陣列中都含有語法糖，
package mainimport "fmt"func main() { arr := [4]int{1, 2, 3, 4} arr2 := &arr fmt.Println((*arr2)[3]) //陣列中的語法糖 fmt.Println(arr2[3]) //切片 arr3 := []int{10, 20, 30, 40} arr4 := &arr3 fmt.Println((*arr4)[3]) //切片中沒有語法糖 //fmt.Println(arr4[3])}View Code
3、結構體是值型別傳遞
二、深拷貝與淺拷貝
struct 默認是深拷貝
package mainimport "fmt"func main() { stu1 := Student{"zs", 18, 0} fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1) //stu1:=main.Student,0xc0000044a0,{zs 18 0} stu2 := stu1 stu2.name = "ls" fmt.Printf("stu2:=%T,%p,%v \n", stu2, &stu2, stu2) //stu2:=main.Student,0xc000004520,{ls 18 0} fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1) //stu1:=main.Student,0xc0000044a0,{zs 18 0} //修改stu2對stu1沒有任何影響}View Code
實作淺拷貝
1、直接賦值指標地址
package mainimport "fmt"func main() { stu1 := Student{"zs", 18, 0} fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1) //stu1:=main.Student,0xc00005a440,{zs 18 0} stu2 := &stu1 stu2.name = "ls" fmt.Printf("stu2:=%T,%p,%v \n", stu2, stu2, stu2) //stu2:=*main.Student,0xc00005a440,&{ls 18 0} fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1) //stu1:=main.Student,0xc00005a440,{ls 18 0} //修改stu2對stu1有影響}View Code
2、實作結構體淺拷貝：通過new()函式來實體化物件
package mainimport "fmt"func main() { //3、實作結構體淺拷貝：通過new()函式來實體化物件 d4 := new(Dog) d4.name = "多多" d4.color = "棕色" d4.age = 1 d4.kind = "巴哥犬" d5 := d4 fmt.Printf("d4: %T , %v , %p \n", d4, d4, d4) //d4: *main.Dog , &{多多 棕色 1 巴哥犬} , 0xc000040080 fmt.Printf("d5: %T , %v , %p \n", d5, d5, d5) fmt.Println("--------------------------------------") d5.color = "金色" d5.kind = "金毛" fmt.Println("d5修改后：", d5) //d5修改后： &{多多 金色 1 金毛} fmt.Println("d4：", d4) //d4： &{多多 金色 1 金毛}}type Dog struct { name string color string age int8 kind string}View Code
三、struct做函式引數
結構體物件或指標作為函式的引數及函式回傳值
- 結構體物件作為函式引數與結構體指標作為函式引數的不同
- 結構體物件作為函式回傳值與結構體指標作為函式回傳值的不同
四、匿名結構體和匿名欄位
匿名結構體
- •沒有名字的結構體，無需通過type關鍵字定義就可以直接使用，
- •在創建匿名結構體時，同時要創建物件，
- •匿名結構體由結構體定義和鍵值對初始化兩部分組成
//匿名結構體 addr := struct { province, city string }{"陜西省", "西安市"} fmt.Println(addr)
結構體的匿名欄位
結構體中的欄位沒有名字，只包含一個沒有欄位名的型別，這些欄位被稱為匿名欄位，
- •如果欄位沒有名字，那么默認使用型別作為欄位名，
- •注意：同一個型別只能寫一個，
- •結構體嵌套中采用匿名結構體欄位可以模擬繼承關系，
package mainimport "fmt"type User struct { string byte int8 float64}func main() { // 實體化結構體 user:= User{"Steven" , 'm' , 35 , 177.5} fmt.Println(user) //如果想依次輸出姓名、年齡、身高、性別 fmt.Printf("姓名：%s \n" , user.string) fmt.Printf("身高：%.2f \n" , user.float64) fmt.Printf("性別：%c \n" , user.byte) fmt.Printf("年齡：%d \n" , user.int8)}View Code
五、結構體的聚合
•將一個結構體作為另一個結構體的屬性（欄位），這種結構就是結構體嵌套，
•結構體嵌套可以模擬面向物件中的兩種關系：
- 〇聚合關系：一個類作為另_個類的屬性
- 〇繼承關系：一個類作為另一個類的子類，子類和父類，
package mainimport "fmt"type Address struct { province, city string}type Person struct { name string age int address *Address}func main() { //模擬結構體物件之間的聚合關系 p := Person{} p.name = "Steven" p.age = 35 //賦值方式1： addr := Address{} addr.province = "北京市" addr.city = "海淀區" p.address = &addr fmt.Println(p) fmt.Println("姓名：", p.name) fmt.Println("年齡：", p.age) fmt.Println("省：", p.address.province) fmt.Println("市：", p.address.city) fmt.Println("-----------------------") //修改Person物件的資料，是否會影響Address物件的資料？ p.address.city = "昌平區" fmt.Println("姓名：", p.name) fmt.Println("年齡：", p.age) fmt.Println("省：", p.address.province) fmt.Println("市：", p.address.city) fmt.Println("addr市：", addr.city) //?是否會受到影響？ fmt.Println("-----------------------") //修改Address物件的資料，是否會影響Person物件的資料？ addr.city = "大興區" fmt.Println("姓名：", p.name) fmt.Println("年齡：", p.age) fmt.Println("省：", p.address.province) fmt.Println("市：", p.address.city) fmt.Println("addr市：", addr.city) //?是否會受到影響？ fmt.Println("-----------------------") //賦值方式2 p.address = &Address{ province: "陜西省", city: "西安市", } fmt.Println(p) fmt.Println("姓名：", p.name) fmt.Println("年齡：", p.age) fmt.Println("省：", p.address.province) fmt.Println("市：", p.address.city) fmt.Println("-----------------------")}View Code
六、結構體嵌套模擬繼承關系
•繼承是傳統面向物件編程中三大特征之一，用于描述兩個類之間的關系，一個類（子類、派生類）繼承于另一個類（父類、超類），
•子類可以有自己的屬性和方法，也可以重寫父類已有的方法，
•子類可以直接訪問父類所有的屬性和方法，
•提升欄位：
〇在結構體中屬于匿名結構體的欄位稱為提升欄位，因為它們可以被訪問，就好像它們屬于擁有匿名結構欄位的結構一樣，
〇換句話說，父類中的欄位就是提升欄位，
•繼承的意義：避免重復代碼、擴展類的功能
•采用匿名欄位的形式就是模擬繼承關系，而模擬聚合關系時一定要采用有名字的結構體作為欄位
package mainimport ( "fmt")type Person struct { name string age int sex string}type Student struct { Person schoolName string}func main() { //1、實體化并初始化Person p1 := Person{"Steven", 35, "男"} fmt.Println(p1) fmt.Println("-------------------") //2、實體化并初始化Student // 寫法1： s1 := Student{p1, "北航軟體學院"} printInfo(s1) //寫法2： s2 := Student{Person{"Josh", 30, "男"}, "北外高翻學院"} printInfo(s2) //寫法3： s3 := Student{Person: Person{ name: "Penn", age: 19, sex: "男", }, schoolName: "北大元培學院", } printInfo(s3) // 寫法4： s4 := Student{} s4.name = "Daniel" s4.sex = "男" s4.age = 12 s4.schoolName = "北京十一龍樾" printInfo(s4)}func printInfo(s1 Student) { fmt.Println(s1) fmt.Printf("%+v \n", s1) fmt.Printf("姓名：%s， 年齡：%d ， 性別：%s ，學校：%s \n", s1.name, s1.age, s1.sex, s1.schoolName) fmt.Println("-------------------")}View Code
七、結構體中的方法
• Go語言同時有函式和方法，方法的本質是函式，但是方法和函式又具有不同點，
1、 含義不同
•函式function是一段具有獨立功能的代碼，可以被反復多次呼叫，從而實作代碼復用，而方法method是一個類的行為功能，只有該類的物件才能呼叫，
2、 方法有接受者，而函式無接受者
• Go語言的方法methods—種作用于特定型別變數的函式，這種特定型別變數叫做Receiver (接受者、接收者、接收器），
•接受者的概念類似于傳統面向物件語言中的this或self關鍵字，
• Go語言的接受者強調了方法具有作用物件，而函式沒有作用物件，
•—個方法就是一個包含了接受者的函式，
• Go語言中，接受者的型別可以是任何型別，不僅僅是結構體，也可以是struct型別外的其他任何型別，
3、 函式不可以重名，而方法可以重名
•只要接受者不同，則方法名可以一樣，
package mainimport "fmt"import "base"type Employee struct { name , currency string salary float64}func main() { emp1 := Employee{"Daniel" , "$" , 2000} emp1.printSalary()//員工姓名：Daniel ，薪資：$2000.00 emp1.updateSalary(1000) emp1.printSalary()//員工姓名：Daniel ，薪資：$1000.00 }//printSalary方法func (e Employee) printSalary() { fmt.Printf("員工姓名：%s ，薪資：%s%.2f \n", e.name , e.currency , e.salary)}func (e *Employee) updateSalary(num float64) { e.salary=num}View Code
方法的繼承與重寫
package mainimport "fmt"import "base"type Human struct { name, phone string age int}type Student struct { Human school string}type Employee struct { Human company string}func main() { s1 := Student{Human{"Daniel", "15012345678", 13}, "十一龍樾"} e1 := Employee{Human{"Steven", "17812345678", 35}, "1000phone"} s1.printName() e1.printName() s1.SayHi() e1.SayHi()}//======================方法的繼承=============================func (h *Human) printName() { fmt.Println("大家好！我是%s ", h.name)}//=====================方法的重寫=============================func (h *Human) SayHi() { fmt.Printf("大家好！我是%s ， 我%d歲 ， 聯系方式：%s \n", h.name, h.age, h.phone)}func (s *Student) SayHi() { fmt.Printf("大家好！我是%s ， 我%d歲 ， 我在%s上學，聯系方式：%s \n", s.name, s.age, s.school, s.phone)}func (e *Employee) SayHi() { fmt.Printf("大家好！我是%s ， 我%d歲 ， 我在%s作業，聯系方式：%s \n", e.name, e.age, e.company, e.phone)}View Code
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/67381.html
標籤：Go
上一篇：GO基礎之Map
下一篇：GO基礎之介面