GO入门——6. struct与方法

1 struct

• Go 中的struct与C中的struct非常相似，并且Go没有class
• 使用 type struct{} 定义结构，名称遵循可见性规则
• 支持指向自身的指针类型成员
• 支持匿名结构，可用作成员或定义成员变量
• 匿名结构也可以用于map的值
• 可以使用字面值对结构进行初始化
• 允许直接通过指针来读写结构成员
• 相同类型的成员可进行直接拷贝赋值
• 支持 == 与 !=比较运算符，但不支持 > 或 <
• 支持匿名字段，本质上是定义了以某个类型名为名称的字段
• 嵌入结构作为匿名字段看起来像继承，但不是继承
• 可以使用匿名字段指针

//声明结构类型
type Person struct {
    Name string
    Age  int
}

//包含匿名结构并作为内部成员变量
type FullPerson struct {
    Name    string
    Age     int
    Contact struct {
        Phone, City string
    }
}

//匿名字段名结构
type NoFiledName struct {
    string
    int
}

//嵌入结构
type in struct {
    A string
}
type out struct {
    in
    Name string
}

func funcStruct() {
    //初始化时可以使用p :=&Person{}，实现初始化和获取指针
    //一般采用&Person{}这样做赋值
    per := Person{}
    fmt.Println(per) //{ 0},string默认空字符串，int默认0

    per.Age = 25 //通过.对字段操作

    //无构造函数，初始化可指定字段值
    //Person{"ppjj", 22},可以不写字段名那就必须全部按顺序赋值
    per = Person{
        Name: "pj",
        Age:  24, //结尾都需要逗号
    }
    fmt.Println(per) //{pj 24}

    //struct的函数传入是值传递
    A := func(p Person) {
        p.Age = 10
        fmt.Println(p) //{pj 10}
    }
    A(per)
    fmt.Println(per) //{pj 24},函数中执行的结果并不会修改per
    //使用指针实现对struct的引用传递
    B := func(p *Person) {
        p.Age = 20     //指针struct可以用.直接操作
        fmt.Println(p) //&{pj 20}
    }
    B(&per)
    fmt.Println(per) //{pj 20},函数中传入的是地址，因此此处值也修改了
    //匿名结构
    a := &struct {
        Name string
        Age  int
    }{
        Name: "pj",
        Age:  25,
    }
    fmt.Println(a) //&{pj 25}

    //包含匿名结构的成员变量
    fp := &FullPerson{}
    fmt.Println(fp) //&{ 0 { }}
    fp = &FullPerson{Name: "pj", Age: 25}
    fp.Contact.Phone = "187" //匿名结构成员变量只能通过这种方式进行初始化
    fp.Contact.City = "zz"
    fmt.Println(fp) //&{pj 25 {187 zz}}

    ////匿名字段名结构,初始化时必须按定义的顺序
    nfn := &NoFiledName{"pj", 12}
    fmt.Println(nfn) //&{pj 12}

    //嵌入结构
    o := &out{Name: "pj", in: in{A: "in"}}
    fmt.Println(o) //&{{in} pj}
    o.Name = "ppjj"
    o.A = "in1"
    fmt.Println(o) //&{{in1} ppjj}
    o.in.A = "in2"  
    //两种访问方式，如果两个结构有重名字段则被加入的将被隐藏，只能通过o.in.A这样访问
    fmt.Println(o) //&{{in2} ppjj}
}

2 方法

• Go 中虽没有class，但依旧有method
• 通过显示说明receiver来实现与某个类型的组合
• 只能为同一个包中的类型定义方法
• Receiver 可以是类型的值或者指针
• 不存在方法重载
• 可以使用值或指针来调用方法，编译器会自动完成转换
• 从某种意义上来说，方法是函数的语法糖，因为receiver其实就是
  方法所接收的第1个参数（Method Value vs. Method Expression）
• 如果外部结构和嵌入结构存在同名方法，则优先调用外部结构的方法
• 类型别名不会拥有底层类型所附带的方法
• 方法可以调用结构中的非公开字段

type AA struct {
    Name string
}
type BB struct {
    Name string
}

//接收者为AA,值传递
func (a AA) Print(name string) {
    a.Name = "ppjj"
    fmt.Println(a.Name + name)

}
//接收者为BB,引用传递
func (a *BB) Print(name string) {
    a.Name = "ppjj"
    fmt.Println(a.Name + name)

}
func funcMethod() {
    //值传递，不能修改字段
    a := AA{Name: "pj"}
    a.Print("test")
    fmt.Println(a)
    //引用传递，可以修改字段
    b := BB{Name: "pj"}
    b.Print("test")
    fmt.Println(b)
}