結構體

go語言中的結構體，是一種復合類型，有一組屬性構成，這些屬性被稱為字段。結構體也是值類型，可以使用new來創建。

定義:

type name struct {
    field1 type1
    field2 type2
    ...
}

我們可以看到每一個字段都由一個名字和一個類型構成，不過實際上，如果我們如果不需要使用某個字段時，可以使用”_”來代替它的名字

並且結構體字段可以是任意類型，函數，接口，甚至是結構體本身都可以

使用結構體

定義一個Person結構體

type Person struct {
    name string
    age  int
}

使用

// 字面量形式初始化
var p1 = Person{
    name: "Tom",
    age: 18,
}

var p2 = Person{"Cat", 20}

fmt.Println(p1)          //{Tom 18}                                                                                     
fmt.Println(p1.name)     // Tom
fmt.Println(p2)          // {Cat 20}

p1.age = 20      // 設置p的age字段的值
fmt.Println(p1)     // {Tom 20}
還可以使用new函數來給一個結構體分配內存，並返回指向已分配內存的指針

var p3 *Person   // 聲明一個Person類型的指針
p3 = new(Person)   // 分配內存

// 上面兩句相當於
p3 := new(Person)

p3.name = "Cat"
p3.age = 10

fmt.Println(p3)       // &{Cat 10}
fmt.Println(p3.name)  // 
 

我們可以直接使用結構體指針通過”.”來訪問結構體的字段，就像直接使用結構體實例一樣,　go會自動進行轉換

還有一種叫做混合字面量的語法來聲明，如下，這其實只是一種簡寫方式，底層還是調用new方法

var p4 = &Person{"Dog", 10}  // 同樣返回的是Person類型的指針

fmt.Println(p4)             // &{Dog 10}
fmt.Println(p4.name)        // Dog

匿名字段

go語言的結構體還支持匿名字段，也就是說一個只有類型而沒有字段名(連”_”都沒有)的字段,被匿名嵌入的也可以是任何類型,此時類型名就是字段的名字，也就是我們可以直接使用類型名為字段名來訪問匿名字段.

另外如果匿名字段是另一個結構體，這就叫做內嵌結構體，這個特性可以模擬類似繼承的行為。

type Person struct {
    name string
    age  int
}

type Student struct {
    Person
    int
}

// 定義一個Student類型的變量
var s = Student{Person{"gdb", 10}, 10}

// 可以使用如下的方法訪問內部結構體中的字段
fmt.Println(s.Person.name)

// 也可以這樣訪問，go將自動使用Person的name屬性，不過如果在Student中也定義了name字段，這裏就不能使用了
fmt.Println(s.name)

// 訪問int類型的匿名字段,此時類型就是字段的名字
fmt.Println(s.int)
 

註意：這樣如果兩個字段有相同的名字時，外部的名字會覆蓋內部的；如果同一級別出現相同名字的字段，會出錯，需要註意;並且不能同時嵌?某?類型和其指針類型，因為它們名字相同。

標簽

結構體中的字段除了可以有名稱和類型以外，還可以有標簽。它是一個附屬於字段的字符串，可以是文檔或其他的重要標記。後面說反射時再說。

方法

之前學習的面向對象語言，比如說Java, Python中，有類的概念，每個類都可以有自己的成員變量，成員方法，它們都是定義在類中的

go語言中的結構體就類似與面向對象語言的類，而結構體的字段就相當於類中的成員變量，結構體也可以有方法，但是不是直接定義在結構體中的，go語言中有一個接收者的概念，我們可以將函數作用在一個接收者，此時這個函數就被稱為方法

接收者是某種類型的變量，不僅僅可以是結構體，幾乎任何類型都可以是結構體，比如: int,bool, string或數組的別名類型，甚至可以是函數類型，不過不能是接口類型

定義方法的示例:

type Person struct {
    name string
    age int
}

// 使用Person類型的實例做接收者,這就是一個Person類型方法，方法名前面括號中的就是接收者
func (this Person) getName() string {
    return this.name
}

// Peron類型的指針對象也可以作為接收者
func (this *Person) setName(name string) {
    this.name = name
}

tom := Person{"Tom", 20}
fmt.Println(tom)  // {Tom 20}
fmt.Println(tom.getName())  // Tom

tom.changeName("Bob")
fmt.Println(tom)  // {Bob 20}

這裏有一點需要註意：類型和綁定它的方法必須在同一個包中（不一定要在同一個文件中）

這裏使用類型直接作為接收著 和 類型的指針作為接收者的區別，就相當於普通函數中，值類型的參數和引用類型參數的區別；即在方法中對類型的實例的操作，不會影響外部的實例的值，而使用類型指針的實例作為引用參數，在方法內部修改會影響外部的實例

匿名字段

我們也可以使用結構體內部的匿名字段，作為方法的接收者，此時這個結構體，仍然可以調用這個方法，此時編譯器會負責查找

type Person struct {
    name string
    age int
}

type Student struct {
    Person
    score int
}

func (p *Person) show() {
    fmt.Println("My name is " + p.name + ", I‘m " + strconv.Itoa(p.age) + " years old")
}


tom := Person{"Tom", 20}
// 調用匿名字段作為接收器的方法
tom.show()   // My name is Tom, I‘m 20 years old

在此基礎上，我們還可以在結構體上，實現與匿名字段同名的方法，就像面向對象中的重寫類似，編譯器會先查找結構體實例作為接收器的方法。

方法集

根據定義結構體以及方法的不同，方法集也有所不同，了解他們，對理解接口有幫助

type T struct {
    name string
    age int
}

type G struct {
    T
    action string
}

type S struct {
    *T
    sel string
}

• 類型 T 的方法集包含所有接收者為 T　的方法
• 類型T的方法集包含所有接收者為 T的方法(因為go會自動解引用)和所有接收者為 T 的方法
• 類型G包含匿名字段 T, 則G的方法集，僅僅包含T類型的方法集
• 類型S包含匿名字段 *T,則S的方法集，包含T和*T類型的方法集

go語言學習-結構體