Go語言之結構體與方法

一、結構體

結構體是一系列屬性的集合(類似於 Python 中的類)

1、結構體的定義與使用

// 定義
type Person struct {
   Name string
   Age int
   Sex string
}

func main() {
   // 使用
   var per Person
   per.Name="XiaoYang"
   fmt.Println(per)
}

2、定義並賦初值

type Person struct {
   Name string
   Age  int
   Sex  string
}

func main() {
   var per1 Person = Person{Name: "XiaoYang"}         // 按關鍵字傳參,可以少傳
   var per2 Person = Person{"Bob", 20, "男"}  // 按位置傳參,全傳

   fmt.Println(per1) // 輸出:{XiaoYang 0 }
   fmt.Println(per2) // 輸出:{Bob 20 男}
}

3、匿名結構體(隻使用一次,沒有名字)

// 定義個匿名結構體並實例化之後賦值給瞭 hobby 變量
hobby := struct {
   HobbyId   int
   HobbyName string
}{HobbyId: 1, HobbyName: "籃球"}

fmt.Println(hobby)  // 輸出:{1 籃球}
fmt.Println(hobby.HobbyName) // 輸出:籃球

4、結構體的零值

定義好的結構體沒有被初始化時,該結構體的字段將默認賦值為零值

也就是我屬性的零值,所以他是值類型,參數傳遞,copy 傳遞,在函數中修改不會影響原來的

type Person struct {
   Name string
   Age  int
   Sex  string
}

func main() {
   var per Person=Person{"Bob", 20, "男"}
    
   fmt.Println(per) // 輸出:{Bob 20 男}
   test(per)  // 輸出:{Bob 20 男}
   fmt.Println(per) // 輸出:{Bob 20 男}
}

func test(per Person)  {
   per.Age=20
   fmt.Println(per)
}

5、結構體的指針

// & 放在變量前,表示取該變量的地址
// * 放在類型前,表示指向該類型的指針(變量定義,指定類型時才會用到) *[3]int  和 [3]*int
// * 放在變量前,表示解引用(取出指針指向的具體的值)


type Person struct {
 Name string
 Age  int
 Sex  string
}

func main() {
 var per1 *Person
 fmt.Println(per1) // 輸出:<nil>  表示指針類型

 // 定義並初始化
 var per2 *Person = &Person{}
 fmt.Println(per2) // 輸出:&{ 0 }
    
 // 把per2的名字改成XiaoYang
 (*per2).Name = "XiaoYang"
    
 // 也支持直接使用
 per2.Name = "Bob"
 fmt.Println(per2) // 輸出:&{Bob 0 }

}

6、匿名字段(字段沒有名字,隻有類型)

可用於【變量提升 / 提升字段】類似於面向對象的繼承

// 定義一個結構體,匿名字段類型就是字段名字,所有類型不能重復
type Person struct {
   string
   int
   Sex  string
}

func main() {
   per := Person{"XiaoYang", 20, "男"} // 字段匿名,類型就是字段名
   fmt.Println(per)   // 輸出:{XiaoYang 20 男}
   fmt.Println(per.string) // 輸出:XiaoYang
}

7、嵌套結構體(結構體中套結構體)

type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby Hobby       // Person中嵌套Hobby結構體字段
}

type Hobby struct {
   HobbyId   int
   HobbyName string
}

func main() {
   per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"籃球"}}
    
   fmt.Println(per)  // 輸出:{XiaoYang 20 男 {1 籃球}}
   fmt.Println(per.Name) // 輸出:XiaoYang
   fmt.Println(per.Hobby.HobbyName) // 輸出:籃球
}

8、字段提升

結構體中有匿名的結構體類型字段,則該匿名結構體裡的字段就稱為提升字段,可以從外部直接訪問

type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby     // Person中嵌套Hobby匿名結構體字段
}

type Hobby struct {
   HobbyId   int
   HobbyName string
}

func main() {
   per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"籃球"}}
   
   // 打印愛好的名字(Hobby是一個匿名字段,會字段提升)
   fmt.Println(per.HobbyName)   // 輸出:籃球
    
   // per.hobby 類似於面向對象中的super()
   fmt.Println(per.Hobby.HobbyName)  // 輸出:籃球
}


// ------------------------------------------------------------------------------------


// 當子類和父類中的字段名一樣時,就像面向對象的繼承,子類繼承父類(結構體嵌套,匿名字段),子類可以直接調用父類中的屬性或方法

type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby     // Person中嵌套Hobby匿名字段
}

type Hobby struct {
   HobbyId   int
   Name      string
}

func main() {
   per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"籃球"}}
   
   fmt.Println(per.Name)  // 輸出:XiaoYang ——>優先使用自己的
   fmt.Println(per.Hobby.Name)  // 輸出:籃球    ——>指定打印Hobby的名字
}

9、結構體相等性

結構體是值類型。

如果它的每一個字段都是可比較的,則該結構體也是可以比較的。

如果兩個結構體變量的對應字段相等,則兩個變量也是相等的。

如果結構體包含不可比較的字段,則結構體變量也不可比較。

type Person struct {
   Name string
   Age  int
   Sex  string
   // 包含不可比較的字段
   Test []int ——>這是引用類型不可比較
}

func main() {
   // 值類型可以直接==比較,引用類型隻能跟nil用==比較
   per1 := Person{Name: "XiaoYang"}
   per2 := Person{Name: "XiaoYang"}
   per3 := Person{Name: "XiaoYang", Age: 20}
    
   fmt.Println(per1 == per2)  // 輸出:ture ——>包含不可比較類型都會直接報錯
   fmt.Println(per1 == per3)  // 輸出:false
}

二、方法

方法就是一個特殊函數,在函數的基礎上加瞭一些東西

func這個關鍵字和方法名中間加入一個特殊的接收器類型,接收器可以是結構體類型,也可以是非結構體類型

1、方法的定義和使用

type Person struct {
   Name string
   Age  int
   Sex  string
}

// 定義一個方法:給Person結構體綁定一個方法,oneself(名字隨便取)類似於Python類中的self
func (oneself Person) printName()  {
   // 在方法內使用oneself
   fmt.Println(oneself.Name)
}

func main() {
   // 使用,對象調用方法
   per := Person{}
   per.Name = "XiaoYang"
   // 綁定給對象的方法
   per.printName()       // 輸出:XiaoYang
}

2、有瞭函數為啥還需要方法?

方法功能都能實現,但是呢?它就能指定給某個對象瞭 。

type Person struct {
   Name string
   Age  int
   Sex  string
}

// 方法
func (oneself Person) printName() {
   fmt.Println(oneself.Name)
}

// 函數
func printName(oneself Person)  {
   fmt.Println(oneself.Name)
}

func main() {
   per := Person{Name: "XiaoYang"}

   per.printName()  // 方法的特殊之處,可以自動傳遞值
   printName(per)  // 函數需要手動傳遞值
}

3、指針接收器與值接收器

type Person struct {
   Name string
   Age  int
   Sex  string
}

// 值接收器修改名字
func (oneself Person) changeName(name string) {
   oneself.Name = name
}

// 指針接收器修改年齡
func (oneself *Person) changeAge(age int) {
   oneself.Age = age
}

func main() {
   per := Person{Name: "XiaoYang", Age: 20}
   fmt.Println(per)  // 輸出:{XiaoYang 20 }

   per.changeName("Bob")// 由於這個是值接收器,它是copy一份傳遞過去所以修改的是copy的不會改掉原來的
   per.changeAge(18)    // 指針接收器,它傳遞的是指針

   fmt.Println(per)  // 輸出:{XiaoYang 18 }
}

/*
什麼時候用指針接收器,什麼時候使用值接收器:
 -想改原來的,就用指針
 -不想改原來的,就用值
*/

5、匿名字段的方法(方法提升)

type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby // 匿名字段
}

type Hobby struct {
   Id   int
   Name string
}

// 打印Person的名字
func (oneself Person) printName() {
   fmt.Println(oneself.Name)
}

// 打印Hobby的名字
func (oneself Hobby) printHobbyName() {
   fmt.Println(oneself.Name)
}

// 打印Hobby的名字
func (oneself Hobby) printName() {
   fmt.Println(oneself.Name)
}

func main() {
   per := Person{Name: "XiaoYang", Hobby: Hobby{1, "籃球"}}
   per.printName()      // 輸出:XiaoYang
   per.printHobbyName() // 輸出:籃球

   // 如果方法重名瞭,優先使用結構體自己的
   per.printName()       // 輸出:XiaoYang
   per.Hobby.printName() // 輸出:籃球
}

6、在方法中使用值接收器 與 在函數中使用值參數

type Person struct {
 Name string
 Age  int
 Sex  string
}

// 在方法中使用值接收器
func (oneself Person) printName() {
 fmt.Println(oneself.Name)
}

// 在函數中使用值參數
func printName(oneself Person) {
 fmt.Println(oneself.Name)
}

func main() {
 per1 := &Person{Name: "XiaoYang"} // per1是個指針
 per2 := Person{Name: "Bob"}

 printName(*per1) // 輸出:XiaoYang
 per1.printName() // 輸出:XiaoYang  ———> 值收器:可以用值來調,也可以用指針來調
 per2.printName() // 輸出:Bob
}

7、在方法中使用指針接收器 與 在函數中使用指針參數

type Person struct {
   Name string
   Age  int
   Sex  string
}

// 在方法中使用指針接收器
func (oneself *Person) printName() {
   fmt.Println(oneself.Name)
}

func (oneself *Person)changeName(name string)  {
   oneself.Name=name

}

// 在函數中使用指針參數
func printName(oneself *Person) {
   fmt.Println(oneself.Name)
}

func main() {
   per1 := Person{Name: "XiaoYang"} 
   per2 := &Person{Name: "Bob"}   // per1是個指針

   per1.printName()   // 值可以調用
   printName(&per1)

   per2.printName()   // 指針可以調用
   printName(per2)


   per1.changeName("Alen")    // 可以修改
   fmt.Println(per1)

   per2.changeName("YS")     // 可以修改
   fmt.Println(per2)
}

總結:

  •  -不管是值類型接收器還是指針類型接收器,都可以用值來調用,或者指針來調用。
  •  -不管是值還是指針來調用,隻要是值類型接收器,改的就是新的,隻要是指針類型接收器,改的是原來的。

8、非結構體上綁定方法

不允許在基礎數據類型上綁定方法(如:intstring … )

但是自己定義的類型可以綁定方法

type Myint int

func (i *Myint) add() {
   (*i)++
}

func main() {
   var a Myint = 10
   fmt.Println(a) // 輸出:10
   a.add()
   a.add()
   a.add()
   fmt.Println(a) // 輸出:13
}

到此這篇關於Go語言之結構體與方法的文章就介紹到這瞭,更多相關Go語言之結構體內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!

推薦閱讀: