Go語言中沒有“類”的概念，也不支持“類”的繼承等面向?qū)ο蟮母拍钫芟骸o語言中通過結(jié)構(gòu)體的內(nèi)嵌再配合接口比面向?qū)ο缶哂懈叩臄U展性和靈活性。

類型別名和自定義類型

自定義類型

在Go語言中有一些基本的數(shù)據(jù)類型墨叛，如string博其、整型、浮點型植旧、布爾等數(shù)據(jù)類型辱揭， Go語言中可以使用type關(guān)鍵字來定義自定義類型。

自定義類型是定義了一個全新的類型隆嗅。我們可以基于內(nèi)置的基本類型定義界阁，也可以通過struct定義。例如：

//將MyInt定義為int類型
type MyInt int

通過type關(guān)鍵字的定義胖喳，MyInt就是一種新的類型泡躯，它具有int的特性。

類型別名

類型別名是Go1.9版本添加的新功能丽焊。

類型別名規(guī)定：TypeAlias只是Type的別名较剃，本質(zhì)上TypeAlias與Type是同一個類型。就像一個孩子小時候有小名技健、乳名写穴，上學(xué)后用學(xué)名，英語老師又會給他起英文名雌贱，但這些名字都指的是他本人啊送。

type TypeAlias = Type

我們之前見過的rune和byte就是類型別名，他們的定義如下：

type byte = uint8
type rune = int32

類型定義和類型別名的區(qū)別

類型別名與類型定義表面上看只有一個等號的差異欣孤，我們通過下面的這段代碼來理解它們之間的區(qū)別馋没。

//類型定義
type NewInt int

//類型別名
type MyInt = int

func main() {
    var a NewInt
    var b MyInt
    
    fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
    fmt.Printf("type of b:%T\n", b) //type of b:int
}

結(jié)果顯示a的類型是main.NewInt，表示main包下定義的NewInt類型降传。b的類型是int篷朵。MyInt類型只會在代碼中存在，編譯完成時并不會有MyInt類型婆排。

結(jié)構(gòu)體

Go語言中的基礎(chǔ)數(shù)據(jù)類型可以表示一些事物的基本屬性声旺，但是當(dāng)我們想表達一個事物的全部或部分屬性時，這時候再用單一的基本數(shù)據(jù)類型明顯就無法滿足需求了段只，Go語言提供了一種自定義數(shù)據(jù)類型腮猖，可以封裝多個基本數(shù)據(jù)類型，這種數(shù)據(jù)類型叫結(jié)構(gòu)體翼悴，英文名稱struct缚够。 也就是我們可以通過struct來定義自己的類型了幔妨。

Go語言中通過struct來實現(xiàn)面向?qū)ο蟆?/p>

結(jié)構(gòu)體的定義

使用type和struct關(guān)鍵字來定義結(jié)構(gòu)體，具體代碼格式如下：

type 類型名 struct {
    字段名 字段類型
    字段名 字段類型
    …
}

其中：

• 類型名：標識自定義結(jié)構(gòu)體的名稱谍椅，在同一個包內(nèi)不能重復(fù)误堡。
• 字段名：表示結(jié)構(gòu)體字段名。結(jié)構(gòu)體中的字段名必須唯一雏吭。
• 字段類型：表示結(jié)構(gòu)體字段的具體類型锁施。

舉個例子，我們定義一個Person（人）結(jié)構(gòu)體杖们，代碼如下：

type person struct {
    name string
    city string
    age  int8
}

同樣類型的字段也可以寫在一行悉抵，

type person1 struct {
    name, city string
    age        int8
}

這樣我們就擁有了一個person的自定義類型，它有name摘完、city姥饰、age三個字段，分別表示姓名孝治、城市和年齡列粪。這樣我們使用這個person結(jié)構(gòu)體就能夠很方便的在程序中表示和存儲人信息了。

語言內(nèi)置的基礎(chǔ)數(shù)據(jù)類型是用來描述一個值的谈飒，而結(jié)構(gòu)體是用來描述一組值的岂座。比如一個人有名字、年齡和居住城市等杭措，本質(zhì)上是一種聚合型的數(shù)據(jù)類型

結(jié)構(gòu)體實例化

只有當(dāng)結(jié)構(gòu)體實例化時费什，才會真正地分配內(nèi)存。也就是必須實例化后才能使用結(jié)構(gòu)體的字段手素。

結(jié)構(gòu)體本身也是一種類型鸳址，我們可以像聲明內(nèi)置類型一樣使用var關(guān)鍵字聲明結(jié)構(gòu)體類型。

var 結(jié)構(gòu)體實例 結(jié)構(gòu)體類型

基本實例化

舉個例子：

type person struct {
    name string
    city string
    age  int8
}

func main() {
    var p1 person
    p1.name = "上海娜扎"
    p1.city = "北京"
    p1.age = 18
    fmt.Printf("p1=%v\n", p1)  //p1={上海娜扎 北京 18}
    fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"上海娜扎", city:"北京", age:18}
}

我們通過.來訪問結(jié)構(gòu)體的字段（成員變量）,例如p1.name和p1.age等泉懦。

匿名結(jié)構(gòu)體

在定義一些臨時數(shù)據(jù)結(jié)構(gòu)等場景下還可以使用匿名結(jié)構(gòu)體氯质。

package main
     
import (
    "fmt"
)
     
func main() {
    var user struct{Name string; Age int}
    user.Name = "小王子"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

創(chuàng)建指針類型結(jié)構(gòu)體

我們還可以通過使用new關(guān)鍵字對結(jié)構(gòu)體進行實例化，得到的是結(jié)構(gòu)體的地址祠斧。 格式如下：

var p2 = new(person)
fmt.Printf("%T\n", p2)     //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

從打印的結(jié)果中我們可以看出p2是一個結(jié)構(gòu)體指針。

需要注意的是在Go語言中支持對結(jié)構(gòu)體指針直接使用.來訪問結(jié)構(gòu)體的成員拱礁。

var p2 = new(person)
p2.name = "小王子"
p2.age = 28
p2.city = "上海"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王子", city:"上海", age:28}

取結(jié)構(gòu)體的地址實例化

使用&對結(jié)構(gòu)體進行取地址操作相當(dāng)于對該結(jié)構(gòu)體類型進行了一次new實例化操作琢锋。

p3 := &person{}
fmt.Printf("%T\n", p3)     //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "七米"
p3.age = 30
p3.city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"七米", city:"成都", age:30}

p3.name = "七米"其實在底層是(*p3).name = "七米"，這是Go語言幫我們實現(xiàn)的語法糖呢灶。

結(jié)構(gòu)體初始化

沒有初始化的結(jié)構(gòu)體吴超，其成員變量都是對應(yīng)其類型的零值。

type person struct {
    name string
    city string
    age  int8
}

func main() {
    var p4 person
    fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}
}

使用鍵值對初始化

使用鍵值對對結(jié)構(gòu)體進行初始化時鸯乃，鍵對應(yīng)結(jié)構(gòu)體的字段鲸阻，值對應(yīng)該字段的初始值跋涣。

p5 := person{
    name: "小王子",
    city: "北京",
    age:  18,
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"小王子", city:"北京", age:18}

也可以對結(jié)構(gòu)體指針進行鍵值對初始化，例如：

p6 := &person{
    name: "小王子",
    city: "北京",
    age:  18,
}
fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"小王子", city:"北京", age:18}

當(dāng)某些字段沒有初始值的時候鸟悴，該字段可以不寫陈辱。此時，沒有指定初始值的字段的值就是該字段類型的零值细诸。

p7 := &person{
    city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}

使用值的列表初始化

初始化結(jié)構(gòu)體的時候可以簡寫沛贪，也就是初始化的時候不寫鍵，直接寫值：

p8 := &person{
    "上海娜扎",
    "北京",
    28,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"上海娜扎", city:"北京", age:28}

使用這種格式初始化時震贵，需要注意：

1. 必須初始化結(jié)構(gòu)體的所有字段利赋。
2. 初始值的填充順序必須與字段在結(jié)構(gòu)體中的聲明順序一致。
3. 該方式不能和鍵值初始化方式混用猩系。

結(jié)構(gòu)體內(nèi)存布局

結(jié)構(gòu)體占用一塊連續(xù)的內(nèi)存媚送。

type test struct {
    a int8
    b int8
    c int8
    d int8
}
n := test{
    1, 2, 3, 4,
}
fmt.Printf("n.a %p\n", &n.a)
fmt.Printf("n.b %p\n", &n.b)
fmt.Printf("n.c %p\n", &n.c)
fmt.Printf("n.d %p\n", &n.d)

輸出：

n.a 0xc0000a0060
n.b 0xc0000a0061
n.c 0xc0000a0062
n.d 0xc0000a0063

【進階知識點】關(guān)于Go語言中的內(nèi)存對齊推薦閱讀:在 Go 中恰到好處的內(nèi)存對齊

空結(jié)構(gòu)體

空結(jié)構(gòu)體是不占用空間的。

var v struct{}
fmt.Println(unsafe.Sizeof(v))  // 0

面試題

請問下面代碼的執(zhí)行結(jié)果是什么寇甸？

type student struct {
    name string
    age  int
}

func main() {
    m := make(map[string]*student)
    stus := []student{
        {name: "小王子", age: 18},
        {name: "娜扎", age: 23},
        {name: "大王八", age: 9000},
    }

    for _, stu := range stus {
        m[stu.name] = &stu
    }
    for k, v := range m {
        fmt.Println(k, "=>", v.name)
    }
}

構(gòu)造函數(shù)

Go語言的結(jié)構(gòu)體沒有構(gòu)造函數(shù)塘偎，我們可以自己實現(xiàn)。 例如幽纷，下方的代碼就實現(xiàn)了一個person的構(gòu)造函數(shù)式塌。 因為struct是值類型，如果結(jié)構(gòu)體比較復(fù)雜的話友浸，值拷貝性能開銷會比較大峰尝，所以該構(gòu)造函數(shù)返回的是結(jié)構(gòu)體指針類型。

func newPerson(name, city string, age int8) *person {
    return &person{
        name: name,
        city: city,
        age:  age,
    }
}

調(diào)用構(gòu)造函數(shù)

p9 := newPerson("張三", "上海", 90)
fmt.Printf("%#v\n", p9) //&main.person{name:"張三", city:"上海", age:90}

方法和接收者

Go語言中的方法（Method）是一種作用于特定類型變量的函數(shù)收恢。這種特定類型變量叫做接收者（Receiver）武学。接收者的概念就類似于其他語言中的this或者 self。

方法的定義格式如下：

func (接收者變量 接收者類型) 方法名(參數(shù)列表) (返回參數(shù)) {
    函數(shù)體
}

其中伦意，

• 接收者變量：接收者中的參數(shù)變量名在命名時火窒，官方建議使用接收者類型名稱首字母的小寫，而不是self驮肉、this之類的命名熏矿。例如，Person類型的接收者變量應(yīng)該命名為 p离钝，Connector類型的接收者變量應(yīng)該命名為c等票编。
• 接收者類型：接收者類型和參數(shù)類似，可以是指針類型和非指針類型卵渴。
• 方法名慧域、參數(shù)列表、返回參數(shù)：具體格式與函數(shù)定義相同浪读。

舉個例子：

//Person 結(jié)構(gòu)體
type Person struct {
    name string
    age  int8
}

//NewPerson 構(gòu)造函數(shù)
func NewPerson(name string, age int8) *Person {
    return &Person{
        name: name,
        age:  age,
    }
}

//Dream Person做夢的方法
func (p Person) Dream() {
    fmt.Printf("%s的夢想是學(xué)好Go語言昔榴！\n", p.name)
}

func main() {
    p1 := NewPerson("小王子", 25)
    p1.Dream()
}

方法與函數(shù)的區(qū)別是辛藻，函數(shù)不屬于任何類型，方法屬于特定的類型互订。

指針類型的接收者

指針類型的接收者由一個結(jié)構(gòu)體的指針組成吱肌，由于指針的特性，調(diào)用方法時修改接收者指針的任意成員變量屁奏，在方法結(jié)束后岩榆，修改都是有效的。這種方式就十分接近于其他語言中面向?qū)ο笾械?code>this或者self坟瓢。 例如我們?yōu)?code>Person添加一個SetAge方法勇边，來修改實例變量的年齡。

// SetAge 設(shè)置p的年齡
// 使用指針接收者
func (p *Person) SetAge(newAge int8) {
    p.age = newAge
}

調(diào)用該方法：

func main() {
    p1 := NewPerson("小王子", 25)
    fmt.Println(p1.age) // 25
    p1.SetAge(30)
    fmt.Println(p1.age) // 30
}

值類型的接收者

當(dāng)方法作用于值類型接收者時折联，Go語言會在代碼運行時將接收者的值復(fù)制一份粒褒。在值類型接收者的方法中可以獲取接收者的成員值，但修改操作只是針對副本诚镰，無法修改接收者變量本身奕坟。

// SetAge2 設(shè)置p的年齡
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
    p.age = newAge
}

func main() {
    p1 := NewPerson("小王子", 25)
    p1.Dream()
    fmt.Println(p1.age) // 25
    p1.SetAge2(30) // (*p1).SetAge2(30)
    fmt.Println(p1.age) // 25
}

什么時候應(yīng)該使用指針類型接收者

1. 需要修改接收者中的值
2. 接收者是拷貝代價比較大的大對象
3. 保證一致性，如果有某個方法使用了指針接收者清笨，那么其他的方法也應(yīng)該使用指針接收者月杉。

任意類型添加方法

在Go語言中，接收者的類型可以是任何類型抠艾，不僅僅是結(jié)構(gòu)體苛萎，任何類型都可以擁有方法。 舉個例子检号，我們基于內(nèi)置的int類型使用type關(guān)鍵字可以定義新的自定義類型腌歉，然后為我們的自定義類型添加方法。

//MyInt 將int定義為自定義MyInt類型
type MyInt int

//SayHello 為MyInt添加一個SayHello的方法
func (m MyInt) SayHello() {
    fmt.Println("Hello, 我是一個int齐苛。")
}
func main() {
    var m1 MyInt
    m1.SayHello() //Hello, 我是一個int翘盖。
    m1 = 100
    fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

注意事項： 非本地類型不能定義方法，也就是說我們不能給別的包的類型定義方法凹蜂。

結(jié)構(gòu)體的匿名字段

結(jié)構(gòu)體允許其成員字段在聲明時沒有字段名而只有類型馍驯，這種沒有名字的字段就稱為匿名字段。

//Person 結(jié)構(gòu)體Person類型
type Person struct {
    string
    int
}

func main() {
    p1 := Person{
        "小王子",
        18,
    }
    fmt.Printf("%#v\n", p1)        //main.Person{string:"北京", int:18}
    fmt.Println(p1.string, p1.int) //北京 18
}

注意：這里匿名字段的說法并不代表沒有字段名玛痊，而是默認會采用類型名作為字段名泥彤，結(jié)構(gòu)體要求字段名稱必須唯一，因此一個結(jié)構(gòu)體中同種類型的匿名字段只能有一個卿啡。

嵌套結(jié)構(gòu)體

一個結(jié)構(gòu)體中可以嵌套包含另一個結(jié)構(gòu)體或結(jié)構(gòu)體指針，就像下面的示例代碼那樣菱父。

//Address 地址結(jié)構(gòu)體
type Address struct {
    Province string
    City     string
}

//User 用戶結(jié)構(gòu)體
type User struct {
    Name    string
    Gender  string
    Address Address
}

func main() {
    user1 := User{
        Name:   "小王子",
        Gender: "男",
        Address: Address{
            Province: "山東",
            City:     "威海",
        },
    }
    fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

嵌套匿名字段

上面user結(jié)構(gòu)體中嵌套的Address結(jié)構(gòu)體也可以采用匿名字段的方式颈娜，例如：

//Address 地址結(jié)構(gòu)體
type Address struct {
    Province string
    City     string
}

//User 用戶結(jié)構(gòu)體
type User struct {
    Name    string
    Gender  string
    Address //匿名字段
}

func main() {
    var user2 User
    user2.Name = "小王子"
    user2.Gender = "男"
    user2.Address.Province = "山東"    // 匿名字段默認使用類型名作為字段名
    user2.City = "威海"                // 匿名字段可以省略
    fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

當(dāng)訪問結(jié)構(gòu)體成員時會先在結(jié)構(gòu)體中查找該字段剑逃，找不到再去嵌套的匿名字段中查找。

嵌套結(jié)構(gòu)體的字段名沖突

嵌套結(jié)構(gòu)體內(nèi)部可能存在相同的字段名官辽。在這種情況下為了避免歧義需要通過指定具體的內(nèi)嵌結(jié)構(gòu)體字段名蛹磺。

//Address 地址結(jié)構(gòu)體
type Address struct {
    Province   string
    City       string
    CreateTime string
}

//Email 郵箱結(jié)構(gòu)體
type Email struct {
    Account    string
    CreateTime string
}

//User 用戶結(jié)構(gòu)體
type User struct {
    Name   string
    Gender string
    Address
    Email
}

func main() {
    var user3 User
    user3.Name = "上海娜扎"
    user3.Gender = "男"
    // user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
    user3.Address.CreateTime = "2000" //指定Address結(jié)構(gòu)體中的CreateTime
    user3.Email.CreateTime = "2000"   //指定Email結(jié)構(gòu)體中的CreateTime
}

結(jié)構(gòu)體的“繼承”

Go語言中使用結(jié)構(gòu)體也可以實現(xiàn)其他編程語言中面向?qū)ο蟮睦^承。

//Animal 動物
type Animal struct {
    name string
}

func (a *Animal) move() {
    fmt.Printf("%s會動同仆！\n", a.name)
}

//Dog 狗
type Dog struct {
    Feet    int8
    *Animal //通過嵌套匿名結(jié)構(gòu)體實現(xiàn)繼承
}

func (d *Dog) wang() {
    fmt.Printf("%s會汪汪汪~\n", d.name)
}

func main() {
    d1 := &Dog{
        Feet: 4,
        Animal: &Animal{ //注意嵌套的是結(jié)構(gòu)體指針
            name: "樂樂",
        },
    }
    d1.wang() //樂樂會汪汪汪~
    d1.move() //樂樂會動萤捆！
}

結(jié)構(gòu)體字段的可見性

結(jié)構(gòu)體中字段大寫開頭表示可公開訪問，小寫表示私有（僅在定義當(dāng)前結(jié)構(gòu)體的包中可訪問）俗批。

結(jié)構(gòu)體與JSON序列化

JSON(JavaScript Object Notation) 是一種輕量級的數(shù)據(jù)交換格式俗或。易于人閱讀和編寫。同時也易于機器解析和生成岁忘。JSON鍵值對是用來保存JS對象的一種方式辛慰，鍵/值對組合中的鍵名寫在前面并用雙引號""包裹，使用冒號:分隔干像，然后緊接著值帅腌；多個鍵值之間使用英文,分隔。

//Student 學(xué)生
type Student struct {
    ID     int
    Gender string
    Name   string
}

//Class 班級
type Class struct {
    Title    string
    Students []*Student
}

func main() {
    c := &Class{
        Title:    "101",
        Students: make([]*Student, 0, 200),
    }
    for i := 0; i < 10; i++ {
        stu := &Student{
            Name:   fmt.Sprintf("stu%02d", i),
            Gender: "男",
            ID:     i,
        }
        c.Students = append(c.Students, stu)
    }
    //JSON序列化：結(jié)構(gòu)體-->JSON格式的字符串
    data, err := json.Marshal(c)
    if err != nil {
        fmt.Println("json marshal failed")
        return
    }
    fmt.Printf("json:%s\n", data)
    //JSON反序列化：JSON格式的字符串-->結(jié)構(gòu)體
    str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
    c1 := &Class{}
    err = json.Unmarshal([]byte(str), c1)
    if err != nil {
        fmt.Println("json unmarshal failed!")
        return
    }
    fmt.Printf("%#v\n", c1)
}

結(jié)構(gòu)體標簽（Tag）

Tag是結(jié)構(gòu)體的元信息麻汰，可以在運行的時候通過反射的機制讀取出來速客。 Tag在結(jié)構(gòu)體字段的后方定義，由一對反引號包裹起來五鲫，具體的格式如下：

`key1:"value1" key2:"value2"`

結(jié)構(gòu)體tag由一個或多個鍵值對組成溺职。鍵與值使用冒號分隔，值用雙引號括起來臣镣。同一個結(jié)構(gòu)體字段可以設(shè)置多個鍵值對tag辅愿，不同的鍵值對之間使用空格分隔。

注意事項： 為結(jié)構(gòu)體編寫Tag時忆某，必須嚴格遵守鍵值對的規(guī)則点待。結(jié)構(gòu)體標簽的解析代碼的容錯能力很差佑刷，一旦格式寫錯茫因，編譯和運行時都不會提示任何錯誤，通過反射也無法正確取值斜脂。例如不要在key和value之間添加空格聋呢。

例如我們?yōu)?code>Student結(jié)構(gòu)體的每個字段定義json序列化時使用的Tag：

//Student 學(xué)生
type Student struct {
    ID     int    `json:"id"` //通過指定tag實現(xiàn)json序列化該字段時的key
    Gender string //json序列化是默認使用字段名作為key
    name   string //私有不能被json包訪問
}

func main() {
    s1 := Student{
        ID:     1,
        Gender: "男",
        name:   "上海娜扎",
    }
    data, err := json.Marshal(s1)
    if err != nil {
        fmt.Println("json marshal failed!")
        return
    }
    fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}

結(jié)構(gòu)體和方法補充知識點

因為slice和map這兩種數(shù)據(jù)類型都包含了指向底層數(shù)據(jù)的指針苗踪，因此我們在需要復(fù)制它們時要特別注意。我們來看下面的例子：

type Person struct {
    name   string
    age    int8
    dreams []string
}

func (p *Person) SetDreams(dreams []string) {
    p.dreams = dreams
}

func main() {
    p1 := Person{name: "小王子", age: 18}
    data := []string{"吃飯", "睡覺", "打豆豆"}
    p1.SetDreams(data)

    // 你真的想要修改 p1.dreams 嗎削锰？
    data[1] = "不睡覺"
    fmt.Println(p1.dreams)  // ?
}

正確的做法是在方法中使用傳入的slice的拷貝進行結(jié)構(gòu)體賦值通铲。

func (p *Person) SetDreams(dreams []string) {
    p.dreams = make([]string, len(dreams))
    copy(p.dreams, dreams)
}

同樣的問題也存在于返回值slice和map的情況，在實際編碼過程中一定要注意這個問題器贩。