9.1 结构体

结构体是值类型，所以也可以用new来创建。
结构体中，字段名是唯一的。
Go中没有面向对象语言中的类，而结构体struct实现了类似的功能。所以可以把结构体struct想象成一个没有方法的轻量级的类。
声明：

  1. type myst struct {
  2.     name string
  3.     age  int
  4.     sex  bool
  5. }

初始化：

  1.     s := myst{}     //初始化
  2.     s1 := new(myst) //分配内存
  3.     fmt.Println(s)  //返回字段的零值{ 0 false}
  4.     fmt.Println(s1) //返回内存的指针&{ 0 false}

结构体支持嵌套，也就是结构体的字段也可以是结构体。

9.1.1 工厂模式

  1. package main
  3. import "fmt"
  5. //定义一个结构体
  6. type myst struct {
  7.     name string
  8.     age  int
  9.     sex  bool
  10. }
  12. //定义一个工厂，就是一个函数
  13. func me(name string, age int, sex bool) *myst {
  14.     return &myst{ //返回指针
  15.         name: name,
  16.         age:  age,
  17.         sex:  sex,
  18.     }
  19. }
  21. func main() {
  22.     myinfo := me("吴彦祖", 18, true) //调用
  23.     fmt.Println(*myinfo)          //{吴彦祖 18 true
  24. }

如果不适用工厂模式，上述怎么写：

  1. package main
  3. import "fmt"
  5. //定义一个结构体
  6. type myst struct {
  7.     name string
  8.     age  int
  9.     sex  bool
  10. }
  12. //定义一个工厂
  13. func me(name string, age int, sex bool) *myst {
  14.     m := myst{
  15.         name: name,
  16.         age:  age,
  17.         sex:  sex,
  18.     }
  19.     return &m
  20. }
  22. func main() {
  23.     myinfo := me("吴彦祖", 18, true) //调用
  24.     fmt.Println(*myinfo)          //{吴彦祖 18 true
  25. }

可以发现，就是少了实例化结构体而已。

9.1.2 匿名和内嵌结构体

结构体内的字段可以没有名字，只有类型，类型是必须的。
一个结构体内，同一种类型的匿名字段，只能有一个。
结构体可以内嵌套娃的，以此来实现类似于面向对象的继承。

  1. package main
  3. import "fmt"
  5. type myst struct {
  6.     name string "这是字段的标签" //姓名
  7.     age  int    //年龄
  8.     sex  bool   //性别
  9. }
  11. type myst2 struct {
  12.     int      //匿名字段，身高
  13.     m   myst //结构体类型
  14. }
  16. func main() {
  17.     myinfo := myst2{ //实例化
  18.         188, //匿名字段
  19.         myst{ //内嵌结构体
  20.             name: "吴彦祖",
  21.             age:  18,
  22.             sex:  true,
  23.         },
  24.     }
  25.     fmt.Println(myinfo) //{188 {吴彦祖 18 true}}
  26. }

9.2 方法

结构体就像面向对象中的简化的类，自然也有类方法。
Go中的方法是作用在接收者receiver上的一个函数。接收者可以是任意类型的变量，int，bool，struct等，多用于struct，但是不能是接口类型不能是指针类型，但是可以是其他类型的指针。
也就是说，方法还是面向对象的方法，只不过不是作用在类上，而是作用在类型上，尤其作用在结构体上。简单理解也可以把方法看作是结构体的一个字段。
一个类型（比如一个结构体）是可以有多个方法的。
不同类型的方法是可以同名的。
实现一个改名的例子：

  1. package main
  3. import "fmt"
  5. type cat struct {
  6.     name string //姓名
  7.     age  int    //年龄
  8.     sex  bool   //性别
  9. }
  11. func (c *cat) changename(name string) { //changename方法作用在cat这个结构体上，传入指针
  12.     c.name = name 
  13. }
  14. func main() {
  15.     mycat := cat{
  16.         name: "喵",
  17.         age:  1,
  18.         sex:  true,
  19.     }
  20.     mycat.changename("汪") //传值改名
  21.     fmt.Println(mycat.name) //汪
  22. }

9.2.1 多重继承

Go怎么利用结构体和方法实现多重继承呢？嵌套。
一个结构的两个字段都是结构体，这两个字段又分别有各自的方法，那么实例化第一个结构体，则同时拥有所有的方法。

  1. package main
  3. import "fmt"
  5. //顶结构体，内嵌cat和dog结构体
  6. type Both struct {
  7.     c cat
  8.     d dog
  9. }
  11. //猫结构体
  12. type cat struct {
  13.     name string //姓名
  14.     age  int    //年龄
  15.     sex  bool   //性别
  16. }
  18. //猫改名的方法
  19. func (c *cat) changename(name string) {
  20.     c.name = name
  21. }
  23. //狗结构体
  24. type dog struct {
  25.     name string //姓名
  26.     age  int    //年龄
  27.     sex  bool   //性别
  28. }
  30. //狗改年龄的方法
  31. func (d *dog) changenage(age int) {
  32.     d.age = age
  33. }
  34. func main() {
  35.     a := Both{ //实例化顶结构体
  36.         c: cat{
  37.             name: "喵",
  38.             age:  1,
  39.             sex:  true,
  40.         },
  41.         d: dog{
  42.             name: "汪",
  43.             age:  2,
  44.             sex:  false,
  45.         },
  46.     }
  47.     a.c.changename("喵2")           //改猫名
  48.     a.d.changenage(3)              //改狗年龄
  49.     fmt.Println(a.c.name, a.d.age) //喵2 3
  51. }