Go笔记(八)：结构体

1、类型定义与类型别名

1.1、类型定义

　　语法：

type NewType Type

　　NewType：表示自定义类型

　　Type：表示现有类型

package main

import "fmt"

// 类型定义
func definestruct() {
   type SnailsInt int
   // si为 SnailsInt 类型
   var si SnailsInt = 10
   fmt.Printf("si: %T, %v\n", si, si)
}

func main() {
   definestruct()
}

　　执行结果如下：

 

1.2、类型别名

　　语法：

type NewType = Type

　　NewType：表示自定义类型

　　Type：表示现有类型

package main

import "fmt"

// 类型别名
func typealias() {
   type SnailsString = string
   // str为 string类型
   var str SnailsString = "hello world!"
   fmt.Printf("str: %T, %v\n", str, str)
}

func main() {
   typealias()
}

1.3、类型定义与类型别名的区别

　　1、类型定义是定义一个全新的类型；类型别名是使用一个别名替换之前的类型，没有定义新的类型;

　　2、类型别名只在源码中存在，编译后的文件中不存在此别名;

　　3、类型别名可以调用原来类型的方法;类型定义无法调用原来类型的任何方法。

2、结构体

　　结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

　　Go语言中数组可存储同一类型的数据，结构体中可以为不同项定义不同的数据类型。Go语言没有面向对象的概念，可以使用结构体来实现面对对象的特性(继承、组合)。

3、结构体的声明

　　结构体定义需要使用 type 和 struct 关键字。struct 定义一个新的数据类型，结构体中有一个或多个成员；type 设定了结构体的名称。

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

　　type：结构体定义关键字；

　　struct_variable_type：结构体类型名称

　　struct：结构体定义关键字

　　member definition：成员定义

1、只声明未做初始化的结构体，成员变量用默认值

package main

import "fmt"

// 定义结构体
type StudentStruct struct {
   name string
   stuid string
   age int
}

// 只声明未做初始化的结构体，成员变量用默认值
func studentStructDemo() {
   var ss StudentStruct
   fmt.Printf(" ss : %v\n", ss)
}

func main() {
   studentStructDemo()
}

　　执行结果如下:

2、结构体，相同数据类型可定义在同一行

package main

import "fmt"

// 定义结构体，相同数据类型可定义在同一行
type StructTeacher struct {
   tid, name string
    age int
}
// 只声明未做初始化的结构体，成员变量用默认值
func structTeacherDemo() {
   var st StructTeacher
   fmt.Printf("st: %v\n", st)
}

func main() {
   structTeacherDemo()
}

　　执行结果如下：

4、结构体的初始化

1、语法

　　一旦定义了结构体类型，就可用于变量的声明，格式如下：

variable_name := structure_variable_type {value1, value2...valuen}

　　或

variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

2、示例代码

package main

import "fmt"

// 定义结构体
type StudentStruct struct {
   name string
   stuid string
   age int
}

// 初始化结构体
func initStruct() {
   // 方式一：值列表初始化
   stu := StudentStruct{"timi", "202208071430", 12}
   fmt.Printf("stu: %v\n", stu)
   // 方式二：键值对初始化
   var stu01 = StudentStruct{name: "zs", stuid: "202304182156", age: 13}
   fmt.Printf("stu01: %v\n", stu01)
}

func main() {
   initStruct()
}

　　执行结果如下：

 　初始化部分结构体变量：

package main

import "fmt"

// 初始化部分变量，未初始化的变量为默认值
func initPartStruct() {
   // 初始化变量
   var stu = StudentStruct{name: "zs", age: 13}
   fmt.Printf("stu: %v\n", stu)
}

func main() {
   initPartStruct()
}

　　执行结果如下：

5、匿名结构体

　　匿名结构体无需定义结构体名，直接使用，定义在方法内部。　　

package main

import "fmt"

// 匿名结构体
func secretStruct() {
   var cat struct {
      name string
      age int
   }
   cat.name = "kite"
   cat.age = 1
   fmt.Printf("cat: %T\n %v\n", cat, cat)
}

func main() {
   secretStruct()
}

　　执行结果如下：

6、结构体指针

1、语法

　　结构体指针：指向结构体的指针。

var struct_pointer *struct_type

　　struct_pointer : 结构体指针名称

　　struct_type : 自定义结构体类型

2、示例代码

package main

import "fmt"

type StructPerson struct {
   name string
   age int
}
// 结构体指针
func pointerstructStruct() {
   var per *StructPerson
   timi := StructPerson{"zs", 30}
   per = &timi
   // 取结构体指针的地址
   fmt.Printf("per: %p\n", per)
   fmt.Printf("timi: %p\n", &timi)
   fmt.Printf("per: %v\n", &per)
   // 取结构体指针的元素值
   fmt.Printf("per: %v\n", *per)
}

func main() {
   pointerstructStruct()
}

　　执行结果如下：

 　使用new的方式创建结构体指针，示例代码如下：

package main

import "fmt"

type StructPerson struct {
   name string
   age int
}

// 结构体指针，通过  结构体名.成员变量名  访问结构体
func visitStruct() {
   per := new(StructPerson)
   fmt.Printf("per: %v\n", per)
   per.name = "timi"
   per.age = 12
   fmt.Printf("per: %v\n", per)
   fmt.Printf("per: %v\n", &per)
   fmt.Printf("per: %v\n", *per)
}

func main() {
   visitStruct()
}

　　执行结果如下：

7、结构体作为函数参数

　　结构体可以作为函数的参数，传递给函数

1、传递结构体

　　结构体作为参数传递，传递的是一个结构体副本，函数内部不会改变外部结构体内容。

package main

import "fmt"

type StructPerson struct {
   name string
   age int
}

// 结构体作为函数参数
func changeStruct(per StructPerson) {
   per.name = "ls"
   per.age = 32
}

func paramStruct() {
   per01 := StructPerson{"zs", 45}
   fmt.Printf("per01: %v\n", per01)
   // 结构体作为参数传值，值传递，传递的是一个结构体副本，外部传递的结构体内容不会改变
   changeStruct(per01)
   fmt.Printf("per01: %v\n", per01)
}

func main() {
   paramStruct()
}

　　执行结果如下：

2、传递结构体指针

　　结构体指针作为参数传递，函数内部会改变外部结构体内容。

package main

import "fmt"

type StructPerson struct {
   name string
   age int
}

// 结构体指针作为函数参数
func changeStructPoint(per *StructPerson) {
   per.age = 32
}

func paramStructPointer() {
   per01 := StructPerson{"zs", 45}
   fmt.Printf("per01: %v\n", per01)
   // 结构体指针作为参数传值，传递的是一个结构体指针，函数内部修改影响外部结构体的内容
   changeStructPoint(&per01)
   fmt.Printf("per01: %v\n", per01)
}

func main() {
   paramStructPointer()
}

　　执行结果如下：

8、结构体的嵌套

　　Go语言中无面对对象的思想，同时也无继承关系，但可通过结构体嵌套实现这些特性。

package main

import "fmt"

// 嵌套结构体
func nestStruct() {
   type Book struct {
      bname string
      pagenum int
   }
   bk := Book{"平凡的世界", 257}

   type Person struct {
      pname string
      age int
      // 嵌套结构体(组合)
      book Book
   }
   per := Person{
      pname: "zs",
      age: 12,
      book: bk,
   }
   fmt.Printf("per: %v\n", per)
   fmt.Printf("per.book.bname: %v\n", per.book.bname)
   fmt.Printf("per.book.pagenum: %v\n", per.book.pagenum)
}

func main() {
   nestStruct()
}

　　执行结果如下：

　　可通过结构体嵌套实现面对对象的继承特性。

 

package main

import "fmt"

// 定义动物结构体
type Animal struct {
   name string
   age int
}
func (a Animal) eat() {
   fmt.Println(a.name + " start eat... ")
}
// 定义狮子结构体，嵌套动物结构体 等价于  Lion继承自Animal
type Lion struct {
   Animal
}
// 定义大象结构体，嵌套动物结构体 等价于  Lion继承自Animal
type Elephant struct {
   Animal
}

func main() {
   lion := Lion{
   Animal{
         name: "美洲狮",
         age: 12,
      },
   }
   elephant := Elephant{
      Animal{
         name: "非洲象",
         age: 6,
      },
   }
   lion.eat()
   elephant.eat()
}

 

9、结构体集合

　　Go中的数组存放相同类型的数据，结构体作为Go中一种复杂数据类型也可存储在数组中。详情如下：

package main

import "fmt"

type StructPerson struct {
   name string
   age int
}

// 结构体集合
func structCollection() {
   var per01 []*StructPerson
   per01 = []*StructPerson{
       {"zs", 12},
       {"ls", 15},
   }
   for _, v := range per01 {
       fmt.Printf("v.name: %v\n", v.name)
       fmt.Printf("v.age: %v\n", v.age)
   }
}

func main() {
   structCollection()
}

　　执行结果如下：

10、模拟构造函数

　　Go语言中没有Java语言中构造器的概念，但可使用函数来模拟构造函数的功能。

package main

import "fmt"

type Student struct {
   name string
   age int
}
func newStudent(name string, age int) (*Student, error) {
   if name == "" {
      return nil, fmt.Errorf("name is not blank")
   }
   if age < 0 {
      return nil, fmt.Errorf("age must ge 0")
   }
   return &Student{name: name, age: age}, nil
}
// 模拟构造器
func main() {
   stu, err := newStudent("jack", 12)
   if stu == nil {
      fmt.Printf("err: %v\n", err)
   } else {
      fmt.Printf("stu: %v\n", *stu)
   }
   stu1, err1 := newStudent("peater", -12)
   if stu1 == nil {
      fmt.Printf("err: %v\n", err1)
   } else {
      fmt.Printf("stu: %v\n", *stu1)
   }
}