Go (三) 面向对象1

一、面向对象

1.1、初识golang面向对象

golang支持面向对象编程(OOP)。

golang没有类(class)，go语言的结构体（struct）和其他编程语言的类（class）有同等的地位。简单理解golang是根据struct来实现面向对象编程(OOP)的。

golang有面向对象的继承，封装和多态的特性

golang面向对象很优雅，通过(interface)关联，耦合性低，很灵活。也就是说golang中面向接口编程是非常重要的特性。

二、面向对象-结构体(struct)和结构体变量（值类型）

2.1、结构体(struct)和结构体变量的快速入门（更多方式：详见2.4）

快速理解：可以把"结构体"理解为"类"，"结构体变量"理解为"对象"

// 定义结构体变量，也叫做"对象"
type Cat struct {
	Name string
	Age int
	Color string
}

func main() {
	// 创建一个结构体变量"cat"，类型为"Cat"，是一个struct
	var cat1 Cat
	fmt.Println(cat1) // 返回的默认值：{ 0 } ，string默认值为""，int默认值为0，所以这里显示只有一个0

	// 给变量的"属性"赋值
	cat1.Color="yellow"
	cat1.Age=2
	cat1.Name="dandan"

	fmt.Println(cat1) // 返回值：{dandan 2 yellow} 分别对应Name，Age，Color的值
	fmt.Println(cat1.Name) // 返回值：dandan
	fmt.Println(cat1.Age) // 返回值：2
	fmt.Println(cat1.Color) // 返回值：yellow
	fmt.Printf("%T",cat1) // 类型：main.Cat
}

2.2、结构体变量在内存中的布局（重要）

1.声明一个结构体变量时，数据结构已经存在了，数据的值就是不同类型的默认值(string默认为空,int类型默认为0)；

2.结构体变量是值类型（相互数据不影响，如果想要相互数据影响的话，详见：2.5）

2.3、结构体(struct)声明

type 结构体名称 struct {

     field1 type

     field2 type

}

2.3.1、结构体(struct)声明例子

结构体名称首字母大写，那么结构体可以在其他包被使用

结构体(字段|属性)首字母大写，那么结构体字段可以在其他包被使用

不同结构体变量的字段是独立的，互不影响

type Cat struct {
   Name string  // (字段|属性)是string类型
   Age int  // (字段|属性)是int类型
   Color string  // (字段|属性)是string类型
}

2.3.2、创建一个结构体变量后，如果没有给字段赋值，那么会有一个默认值：

布尔类型的默认值是：false

string类型的默认值是：""

int类型的默认值是：0

指针，slice(切片)和map的默认值都是nil，即没有分配内存空间（在使用时，需要先make）

例子如下：

// 定义结构体变量，也叫做"对象"
type Test struct {
	par1 *int  // 指针
	slice1 []int  // 切片
	map1 map[string]string  // map
}

func main() {
	// 定义结构体变量
	var test Test
	fmt.Println(test.par1) // 默认值：<nil>
	fmt.Println(test.slice1) // 默认值：[]
	fmt.Println(test.map1)  // 默认值：map[]
	if test.par1 == nil {
		fmt.Println("test.par1 is nil")
	}
	if test.slice1 == nil {
		fmt.Println("test.slice1 is nil")
	}
	if test.map1 == nil {
		fmt.Println("test.map1 is nil")
	}
	// 依次输出：
	// test.par1 is nil
	// test.slice1 is nil
	// test.map1 is nil

	// 此时给"结构体变量"直接赋值，一定会报错。需要先给切片make，在使用
	test.slice1=make([]int,2)
	test.slice1[0]=111
	test.slice1[1]=222
	fmt.Println(test.slice1) // [111 222]

	//需要先给map make，在使用
	test.map1=make(map[string]string)
	test.map1["name"]="sudada"
	test.map1["age"]="18"
	fmt.Println(test.map1) // map[age:18 name:sudada]
}

2.4、结构体变量的声明和结构体变量字段使用

2.4.1、方式1（先声明结构体变量，然后赋值）

var test struct

// 定义结构体变量，也叫做"对象"
type Test struct {
	Name string
	Age int
}

func main() {
	var test Test
	test.Name="sudada"
	test.Age=18
	fmt.Println(test) // {sudada 18}
}

2.4.2、方式1的延伸（先声明结构体变量，然后赋值）

var test = struct{}

// 定义结构体变量，也叫做"对象"
type Test struct {
	Name string
	Age int
}

func main() {
	var test = Test{}
    // 简写 test := Test{}
	test.Name="sudada"
	test.Age=18
	fmt.Println(test) // {sudada 18}
}

2.4.3、方式2（声明结构体变量，同时赋值）

var test = struct{Name: "sudada",Age: 18,}

// 定义结构体变量，也叫做"对象"
type Test struct {
	Name string
	Age int
}

func main() {
	var test = Test{
		Name: "sudada",
		Age: 18,
	}
    // 或者简写
	test := Test{
		Name: "sudada",
		Age: 18,
	}
    // 或者这样写
    var test = Test{"sudada",18}
    test := Test{"sudada",18}

	fmt.Println(test) // {sudada 18}
}

2.4.4、方式3（结构体变量是一个指针时，然后赋值）

var test *struct = new(struct)

// 定义结构体变量，也叫做"对象"
type Test struct {
	Name string
	Age int
}

func main() {
	// 结构体变量是一个"指针"
	var test *Test = new(Test)  // 可以简写成：var test = new(Test)
	// 给"指针"类型的"结构体变量"字段赋值的方式（标准写法）
	(*test).Name="sudada"
	(*test).Age=18
	fmt.Println(*test) // {sudada 18}

	// go为了程序使用方便，针对"指针"类型的结构体变量，底层做了优化：test.Age=18 == (*test).Age=18
	test.Name="wang"
	test.Age=28
	fmt.Println(*test) // {wang 28}
}

2.4.5、方式3的延伸（结构体变量是一个指针时，然后赋值）

var test *struct = &struct{}

// 定义结构体变量，也叫做"对象"
type Test struct {
	Name string
	Age int
}

func main() {
	// 结构体变量是一个"指针"
	var test *Test = &Test{}  // 可以简写成：var test = &Test{}
	// 给"指针"类型的"结构体变量"字段赋值的方式（标准写法）
	(*test).Name="sudada"
	(*test).Age=18
	fmt.Println(*test) // {sudada 18}

	// go为了程序使用方便，针对"指针"类型的结构体变量，底层做了优化：test.Age=18 == (*test).Age=18
	test.Name="wang"
	test.Age=28
	fmt.Println(*test) // {wang 28}
}

2.4.6、方式4（结构体变量是一个指针，同时赋值）

var test *struct = &Test{Name:"sudada", Age:28,}

// 定义结构体变量，也叫做"对象"
type Test struct {
	Name string
	Age int
}

func main() {
	// 结构体变量是一个"指针"，声明时赋值
	var test *Test = &Test{
		Name:"sudada",
		Age:28,
	}
	fmt.Println(*test) // {sudada 28}

	// go为了程序使用方便，针对"指针"类型的结构体变量，底层做了优化：test.Age=18 == (*test).Age=18
	test.Name="wang"
	test.Age=28
	fmt.Println(*test) // {wang 28}
}

2.5、结构体变量将指针赋值给另外一个结构体变量时，内存分配机制

"test2指针"对应的"值"是"test1的指针地址"（那么修改test1或者test2时，2边的值都会跟着改变）

// 定义结构体变量，也叫做"对象"
type Test struct {
	Name string
	Age int
}

func main() {
	var test1 = Test{}
	test1.Name="sudada"
	test1.Age=18

	// 把test1的"指针"赋值给test2
	fmt.Printf("%p\n",&test1) // test1的指针是：0xc000008048
	var test2 *Test = &test1
	fmt.Printf("%p\n",&test2) // test2的指针是：0xc00006a028（test2的指针存放的值就是test1的指针）
	fmt.Printf("%p\n",test2) // test2的值(等于test1的指针)是：0xc000008048
	fmt.Println(*test2) // test2：{sudada 18}

	// 修改"指针"的值时，test1和test2对应的值都会改变
	test2.Name="wang"
	fmt.Println(test1)  // test1：{wang 18}
	fmt.Println(*test2)  // test2：{wang 18}
}

2.6、结构体struct 注意事项

2.6.1、结构体和其他类型进行转换时，需要有完全相同的字段（字段名字，字段个数和字段类型）

type A struct {
	Name string
	Age int
}

type B struct {
	Name string
	Age int
}

func main() {
	var a A
	var b B
	// 这样强制转换不会报错（A B结构体字段名称，字段个数和字段类型相同）
	a = A(b)
	fmt.Println(a,b)  // { 0} { 0}
}

2.6.2、结构体进行type重新定义（相当于取别名），goloang认为是新的数据，但是相互间可以强转

// 结构体1
type Student struct {
	Name string
	Age int
}
// 结构体2
type Stu Student

func main() {
	var stu1 Student
	var stu2 Stu
	// 这样强制转换不会报错（Student Stu结构体字段名称，字段个数和字段类型相同）
	stu1 = Student(stu2)
	fmt.Println(stu1,stu2)  // { 0} { 0}
}

2.6.3、结构体的每个字段都可以写一个tag，该tag可以通过反射机制获取

type student struct {
    Name string `json:"name"`
    Age int `json:"age"`
    Sex string `json:"sex"`
}

import (
	"encoding/json"
	"fmt"
)

// 结构体1
type student struct {
	Name string `json:"name"`
	Age int `json:"age"`
	Sex string `json:"sex"`
}

func main() {
	var stu1 = student{"sudada",18,"nan",}
	fmt.Println(stu1) // {sudada 18 nan}

	// 把结构体变量stu1序列化（这里传入"结构体字段"必须大写，如果不大写"结构体字段"，那么json.Marshal读取不到值）
	jsonStr, err := json.Marshal(stu1)
	if err != nil {
		fmt.Println("报错: ",err)
	} else {
		fmt.Println(string(jsonStr)) // 默认返回的是bytes类型的切片，需要使用string做一下转换
		// 返回值(json格式)：{"Name":"sudada","Age":18,"Sex":"nan"}

		// 结构体字段使用tag之后：
		// 返回值(json格式)：{"name":"sudada","age":18,"sex":"nan"}
	}
}

三、面向对象-方法

3.1、什么是方法？

glang中的方法是作用在指定的数据类型上的，即：方法和指定的数据类型绑定，因此自定义类型，都可以有方法。而不仅仅是struct。

3.2、方法的声明和调用

快速理解方法：可以把"结构体"理解为"类"，"结构体变量"理解为"对象"，方法就是"类"里面定义的函数。

方法被对象调用时：对象.方法()，会把对象本身作为实参传递给方法（默认是值传递，修改后不改变原来的值）

方法的声明：

func (name 结构体名称) 方法名 (实参 实参类型) (返回值 返回值类型){

       代码段

       return 返回值

}

方法的案例1：

// 定义"结构体类型Person"
type Person struct {
	Name string
	age int
}

// "结构体类型Person"的方法，名为"test"
// (person Person)表示：test方法，是给"结构体类型Person"绑定的
func (person Person) test()  {
	// 这里的person的值就等于sudada的值（值拷贝），但是修改person的值，不会影响sudada的值，例子如下：
	person.Name = "Jack"
	fmt.Println("test",person.Name) // 返回值："Jack"
}

func main() {
	// 给"结构体变量aaa"赋值
	var sudada = Person {
		Name: "sudada",
		age: 18,
	}
	// 调用"结构体类型Person"的方法"test"
	sudada.test() // sudada调用test时会把sudada传入test方法内(谁调用就把谁传入)，值拷贝
	fmt.Println("main",sudada.Name)  // 返回值："sudada"
	// A.test() // 不能直接调用"结构体类型Person"的方法"test"
	// test() // 直接调用，会把"test"作为一个函数，而不是方法
}

3.3、方法的快速入门

3.3.1、案例1：给Person结构体添加speak方法（无参数无返回值）

// 定义"结构体类型Person"
type Person struct {
	Name string
	age int
}

// "结构体类型Person"的方法，名为"speak"
func (person Person) speak() {
	fmt.Println(person.Name, "is good man") // 返回值：sudada is good man
}

func main() {
	var p = Person{
		Name: "sudada",
		age: 18,
	}
	p.speak()
}

3.3.2、案例2：给Person结构体添加"jisuan"方法（把方法当做函数一样,接收参数并返回值）

// 定义"结构体类型Person"
type Person struct {
	Name string
	age int
}

// "结构体类型Person"的方法，名为"jisuan"
func (person Person) jisuan(num int) (sum int) {
	res:=0
	for i:=0;i<=num;i++{
		res+=i
	}
	return res
}

func main() {
	var p = Person{
		Name: "sudada",
		age: 18,
	}
	var res int
	res = p.jisuan(1000)
	fmt.Println("求和为",res) // 求和为 500500
}

3.4、方法的调用和传参机制

方法的调用和传参机制，和函数基本一样；

不一样的地方是：对象.方法()，会把对象本身作为实参传递给方法（默认是值传递，修改后不改变原来的值）

3.5、方法的注意事项（重要★★★★★）

3.5.1、结构体类型是值类型，在方法调用中，使用的是值拷贝的传递方式。

3.5.2、为了提高效率，通常将方法和结构体的指针类型绑定，例子：

// 定义"结构体类型Person"
type Person struct {
	Name string
	age int
}

// "结构体类型Person"的方法，名为"test"
// 这里的person作为一个指针类型
func (person *Person) test() {
	// 标准写法：(*person).Name = "Jack"
	// 因为编译器做了优化,可以简写如下：
	person.Name = "Jack"
	fmt.Println(person.Name) // 返回值：Jack
}

func main() {
	var p = Person{
		Name: "sudada",
		age: 18,
	}
	// 标准写法：(&p).test()
	// 因为编译器做了优化,可以简写如下：
	p.test()
	fmt.Println(p.Name)  // 返回值：Jack
}

3.5.3、glang中的方法是作用在指定的数据类型上的，即：方法和指定的数据类型绑定，因此自定义类型，都可以有方法。而不仅仅是struct。比如int,float等也可以有方法。

给int类型创建方法，例子：

type Integer int

func (i Integer)test()  {
	fmt.Println(i) // 返回值：10
}

// 绑定指针，修改值后，其他地方也会跟着修改
func (i *Integer)change()  {
	*i += 1
}

func main() {
	var i Integer = 10
	i.test()
	i.change()
	fmt.Println(i) // 返回值：11
}

3.5.4、方法名大写，可以在其他包使用，反之小写，只能在当前包使用。

3.5.5、如果一个类型实现了String()这个方法，那么调用fmt.Println时，默认会调用这个变量的String()方法进行输出。（输出日志时可以使用），案例：

type Student struct {
	Name string
	Age int
}

func (stu Student) String() string {
	msg := fmt.Sprintf("Name=[%v] Age=[%v]", stu.Name, stu.Age)
	return msg
}

func main() {
	var stu1 Student = Student{
		Name: "sudada",
		Age: 18,
	}
	// 调用fmt.Println方法
	fmt.Println(stu1) // 返回值：Name=[sudada] Age=[18]
}

3.6、方法和函数的区别（重要★★★★★）

3.6.1、调用方式不一样

        函数调用：函数名(参数)

        方法调用：方法绑定的类型变量.方法名(参数)

3.6.2、普通函数：函数接收的参数类型为值类型时，不能将指针类型的数据直接传递。反之：函数接收的参数类型为指针类型时，不能将值类型的数据直接传递。例子如下：

package main

import "fmt"

type Student struct {
	Name string
}

// 函数接收的参数类型为值类型时，不能将指针类型的数据直接传递
func test1(szq Student)  {
	fmt.Println(szq.Name)
}
// 反之：函数接收的参数类型为指针类型时，不能将值类型的数据直接传递
func test2(szq *Student)  {
	fmt.Println(szq.Name)
}

func main() {
	var stu = Student{
		Name: "sudada",
	}
	test1(stu)  // 这里"实参的类"型，必须根据函数"形参接收的类型"去传递
	test2(&stu) // 这里"实参的类"型，必须根据函数"形参接收的类型"去传递
}

3.6.3、方法(如struct方法)：方法的接收值为值类型时，可以用指针类型的变量调用方法，反之：方法的接收值为指针类型时，可以用值类型的变量调用方法。例子如下：

func (stu *Student) test1()  {}   指针传递
func (stu Student) test1()  {}   值传递

package main

import "fmt"

type Student struct {
	Name string
}

// 方法的接收值为指针类型时，可以用值类型的变量调用test1方法
func (stu *Student) test1()  {
	fmt.Println(stu.Name)
}

// 方法的接收值为值类型时，可以用指针类型的变量调用test2方法
func (stu Student) test2()  {
	stu.Name = "test2"
	fmt.Println(stu.Name)
}

func main() {
	var stu1 = Student{
		Name: "sudada",
	}
	var stu2 = Student{
		Name: "wang",
	}
	stu1.test1() // 方法接收的是"指针类型"，但是"值类型的变量"也可以调用，返回值：sudada
	fmt.Println(stu1.Name) // 返回值：sudada

	(&stu2).test2() // 方法接收的是"值类型"，但是"指针类型的变量"也可以调用(虽然使用了&stu2，但是本质上还是属于值传递，因为方法test2接收的类型是值类型)，返回值：test2
	// (&stu2).test2() 等价于 stu2.test2()
	fmt.Println(stu2.Name)  // 返回值：wang（上述&stu2本质上还是属于值传递，因为方法test2接收的类型是值类型，所以变量stu2的值，并没有改变）
}

​编辑文章

四、面向对象-工厂模式

4.1、为什么会用到工厂模式？

golang的结构体没有构造函数，通常使用工厂模式来解决这个问题

4.1、怎么用工厂模式？

当结构体struct的首字母小写，同时又需要在别的包内使用这个结构体时，需要用到工厂模式。

案例一（封装的一种模式）

// model.student.go文件
package model

type student struct {
	Name string
	age int
}

// "student结构体"首字母小写，只能当前文件内使用。
// 通过"工厂模式"可以将"student结构体"在其他包使用。
func NewStudent(name string, age int) *student  {
	return &student{
		Name: name,
		age: age,
	}
}

// 如果"age"字段首字母小写，那么其他包不可以直接访问"age"字段，可以提供一个方法获取"age"字段的值
func (n *student) GetAge() int {
	return n.age
}

// main.go文件
package main

import (
	"Study/go008/demo01/model"
	"fmt"
)

func main() {
	// stu 是一个指针，同时也是"student结构体"的变量(指针)
	stu := model.NewStudent("sudada",18)
	fmt.Println(*stu)  // 返回值：{sudada 18}
	fmt.Println(stu.Name)  // 返回值：sudada

	// fmt.Println(stu.age)  // "student结构体"的age字段是小写，这里不能使用
	// 所以这里给"student结构体"绑定一个"GetAge方法(首字母大写)
	fmt.Println(stu.GetAge())  // "返回值：18
}

五、面向对象-三大特性

面向对象思想-抽象

5.1、封装

5.1.1、什么是封装？

        封装就是把抽象出的字段，和对字段的操作封装在一起，将数据保护在内部，程序的其他包只有通过被授权的操作（方法）才能对字段进行操作。

5.1.2、怎么用封装？

1.对结构体中的属性进行封装；

2.通过方法，包，实现封装；

5.1.3、封装的实现步骤：

1.将结构体，字段，属性的首字母小写；

2.给结构体所在包提供一个工厂模式的函数，首字母大写；

3.提供一个首字母大写的Set方法，用于对属性判断并赋值；

4.提供一个首字母大写的Get方法，用于获取属性的值；

5.1.4、封装的快速入门，案例一

// model/person.go 文件
package model

import "fmt"

type person struct {
	Name string
	age  int
	sal  float64
}

// 工厂模式，返回一个"struct结构体"对象
func NewPerson(name string) *person {
	return &person{
		Name: name,
	}
}

// 设置年龄的"方法"
func (p *person) SetAge(age int) {
	if age > 0 && age < 100 {
		p.age = age
	} else {
		fmt.Println("年龄范围不合法")
		// 给个默认值
		p.age = 18
	}
}
// 获取年龄的"方法"
func (p *person) GetAge() int {
	return p.age
}
// 设置薪资的"方法"
func (p *person) SetSal(sal float64) {
	if sal > 3000 && sal < 30000 {
		p.sal += sal
	} else {
		fmt.Println("薪资范围不对3000-30000")
	}
}
// 获取薪资的"方法"
func (p *person) GetSal() float64 {
	return p.sal
}


// main.go 文件
package main

import (
	"Study/go009/model"
	"fmt"
)

func main() {
	// person是一个"struct结构体"对象
	person := model.NewPerson("sudada")
	// 调用"SetAge"方法，设置年龄
	person.SetAge(22)
	// 调用"SetSal"方法，设置薪资
	person.SetSal(28000)

	// 调用"GetAge"方法，获取年龄
	person_age := person.GetAge()
	// 调用"GetSal"方法，获取薪资
	person_sal := person.GetSal()
	// Name是首字母大写的字段，这里可以直接调用
	fmt.Println(person.Name) // 返回值：sudada
	fmt.Println("Age", person_age) // 返回值：Age 22
	fmt.Println("Sal", person_sal) // 返回值：Age 28000
}

5.2、继承

5.2.1、什么是继承？

继承可以解决代码复用，当多个结构体存在相同的属性(字段)和方法时，可以从这些结构体中抽象出结构体，在该结构体中定义这些相同的属性和方法。

5.2.2、怎么用继承？

语法：

// "学生"结构体
type Student struct {
    Name string
    Age int
}

// "中学"结构体
type School struct {
    Student // 继承"结构体Student"
}

// "大学"结构体
type University struct {
    Student // 继承"结构体Student"
}

继承案例快速理解：

package main

import "fmt"

// "学生"结构体
type Student struct {
	Name string
	Age int
}
// "学生"结构体的方法""
func (stu *Student) score(num int) {
	fmt.Printf("学生:%v 的分数是:%v\n", stu.Name, num)
}

// "中学"结构体
type School struct {
	Student // 继承"结构体Student"
}
// "中学"结构体的方法"testing"
func (s *School) testing()  {
	fmt.Println("school")
}

// "大学"结构体
type University struct {
	Student // 继承"结构体Student"
}
// "大学"结构体的方法"testing"
func (s *University) testing()  {
	fmt.Println("university")
}

func main() {
	// 定义一个结构体变量"middleStu"
	middleStu := &School{}
	// 给结构体变量"middleStu"赋值（方式一）
	//middleStu.Student.Name = "sudada"
	//middleStu.Student.Age = 10
	// 给结构体变量"middleStu"赋值（方式二，简写）
	middleStu.Name = "sudada"
	middleStu.Age = 10
	middleStu.testing()  // 返回值：school
	fmt.Println(*middleStu)  // 返回值：{{sudada 10}}
	// 调用"继承的结构体Student的方法score"
	middleStu.score(80)  // 返回值：学生:sudada 的分数是:80

	// 定义一个结构体变量"UniStu"
	UniStu := &University{}
	// 给结构体变量"UniStu"赋值（方式一）
	//UniStu.Student.Name = "sudada"
	//UniStu.Student.Age = 20
	// 给结构体变量"UniStu"赋值（方式二，简写）
	UniStu.Name = "sudada"
	UniStu.Age = 20
	UniStu.testing()  // 返回值：university
	fmt.Println(*UniStu)  // 返回值：{{sudada 20}}
	// 调用"继承的结构体Student的方法score"
	middleStu.score(150)  // 返回值：学生:sudada 的分数是:150
}

5.2.3、继承的深入理解

1.结构体可以使用"父"结构体所有的字段和方法，即：首字母大写或者小写的字段，方法，都可以使用；

package main

import "fmt"

// "父"结构体
type Student struct {
	Name string
	age int
}
// "父"结构体的方法"score"
func (stu *Student) score(num int) {
	fmt.Printf("学生:%v 的分数是:%v\n", stu.Name, num)
}

// 结构体School 继承"父"结构体Student
type School struct {
	Student // 继承"结构体Student"
}

func main() {
	// 定义一个结构体变量"middleStu"
	middleStu := School{}
	// 结构体School使用"父"结构体Student的 字段
	middleStu.Name = "sudada"
	middleStu.age = 18
	fmt.Println(middleStu.Name) // 返回值：sudada
	fmt.Println(middleStu.age) // 返回值：18
	// 结构体School使用"父"结构体Student的 方法
	middleStu.score(80)  // 返回值：学生:sudada 的分数是:80
}

2."父"结构体字段可以简化；

package main

import "fmt"

// "父"结构体
type Student struct {
	Name string
	age int
}
// 结构体School 继承"父"结构体Student
type School struct {
	Student // 继承"结构体Student"
}

func main() {
	// 定义一个结构体变量"middleStu"
	middleStu := School{}
	// 变量赋值
	middleStu.Student.Name = "sudada"
	middleStu.Student.age = 18
	fmt.Println(middleStu.Student.Name) // 返回值：sudada
	fmt.Println(middleStu.Student.age) // 返回值：18
	// 变量赋值，可以简写为：
	middleStu.Name = "sudada"
	middleStu.age = 18
	fmt.Println(middleStu.Name) // 返回值：sudada
	fmt.Println(middleStu.age) // 返回值：18
}

3.当结构体和和"父"结构体有相同的字段或者方法时，编译器采用就近访问的原则，如果希望访问"父"结构体的字段或方法，就指明"父"结构体的字段或方法来取值；

package main

import "fmt"

// "父"结构体
type Student struct {
	Name string
	age int
}
// 结构体Student的方法
func (st *Student) StudentSayName() {
	fmt.Println(st.Name)
}

// 结构体School 继承"父"结构体Student
type School struct {
	Student // 继承"结构体Student"
	Name string
}
// 结构体School的方法
func (sc *School) SchoolSayName() {
	fmt.Println(sc.Name)
}

func main() {
	// 定义一个结构体变量"middleStu"
	middleStu := School{}

	// 定义结构体School的"Name字段"的值为"sudada"
	middleStu.Name = "sudada"
	// 调用结构体School的方法"SchoolSayName"就能拿到School的Name字段的值
	middleStu.SchoolSayName()  // 返回值："sudada"
	// 调用结构体Student的方法"StudentSayName"拿到Student的Name字段的值为空
	middleStu.StudentSayName()  // 返回值："空"

	// 定义结构体Student的"Name字段"的值为"sudada"
	middleStu.Student.Name = "wangdalu"
	// 调用结构体School的方法"SchoolSayName"就能拿到School的Name字段的值
	middleStu.SchoolSayName()  // 返回值："sudada"
	// 调用结构体Student的方法"StudentSayName"就能拿到Student的Name字段的值
	middleStu.StudentSayName()  // 返回值："wangdalu"
}

4.结构体继承了多个"父"结构体，同时多个"父"结构体有相同的字段或方法，那么在访问时，就需要指定"父"结构体的名字，否则编译报错；

package main

// "父"结构体1（有Name字段）
type A struct {
	Name string
	Age int
}
// "父"结构体2（也有Name字段）
type B struct {
	Name string
}
// 结构体C，继承A，B结构体（没有Name字段）
type C struct {
	A
	B
}

func main() {
	c := C{}
	// 结构体变量c给Name字段赋值时，正确的写法（必须指定"父"结构体的名称）
	c.A.Name="sudada"
	c.B.Name="sudada"

	// 结构体变量c给Name字段赋值，错误的写法（没有指定"父"结构体的名称）
	//c.Name="sudada"
}

5."结构体B,字段aaa"的类型是一个"结构体A"时，这种模式就是组合(A和B组合)。组合模式下，访问"结构体A的字段或方法"，必须带上"结构体B的字段名aaa"；

package main

// 结构体A
type A struct {
	Name string
	Age int
}

// 结构体B
type B struct {
	// "字段aaa"的类型是结构体A
	aaa A
}

func main() {
	b := B{}
	// 组合模式下，想要访问"A结构体"的字段或方法，必须带上"结构体B的字段名aaa"
	b.aaa.Name="sudada"
	// 错误写法
	//b.Name="sudada"
}

6.结构体继承"父"结构体后，在创建结构体变量时，可以直接给"父"结构体的字段赋值；

// 继承结构体
import "fmt"

// 结构体A
type A struct {
	Name string
	Age int
}
// 结构体B（继承A结构体）
type B struct {
	A
}

func main() {
	// 结构体变量赋值，B结构体继承了A结构体，赋值方式: B{ A{Name:"sudada",Age:18} }
	b := B{
		A{
			Name: "sudada",
			Age: 18,
		},
	}
	fmt.Println(b.Name) // 返回值：sudada
	fmt.Println(b.Age) // 返回值：18

	// 错误写法（B结构体虽然继承了A结构体，但是B结构体没有字段Name和Age）
	//c := B{
	//	Name: "sudada",
	//	Age: 18,
	//}
}

// 继承的结构体是一个指针
import "fmt"

// 结构体A
type A struct {
	Name string
	Age int
}
// 结构体B（继承A结构体，是一个指针）
type B struct {
	*A
}

func main() {
	// 结构体变量赋值，B结构体继承了A结构体，赋值方式: B{ A{Name:"sudada",Age:18} }
	b := B{
		// 这里也要适配为指针
		&A{
			Name: "sudada",
			Age: 18,
		},
	}
	fmt.Println(b.Name) // 返回值：sudada
	fmt.Println(b.Age) // 返回值：18
	fmt.Println(b) // 返回值：{ 0xc000094030 } 是一个指针地址
}

7.结构体的匿名字段是基本数据类型时，如何使用

import "fmt"

type A struct {
	Name string
	Age int
}
// 结构体的匿名字段是基本数据类型时，如何使用
type B struct {
	A
	int
}

func main() {
	b := B{}
	b.Name="sudada"
	b.Age=18
	// 结构体变量给基本数据类型赋值，以及使用
	b.int=22
	fmt.Println(b)  // 返回值：{{sudada 18} 22}
}

5.2.4、多重继承（建议少用）

什么是多重继承：一个结构体继承了多个"父"结构体，那么该结构体可以直接访问"父"结构体的字段和方法，实现了多重继承

案例：

package main

// "父"结构体1
type A struct {
	Name string
	Age int
}
// "父"结构体2
type B struct {
	Name string
}
// 结构体C，继承A，B结构体
type C struct {
	A
	B
}

5.3、多态

5.3.1、多态的基本介绍

golang中，多态特征是通过接口实现的。按照统一的接口调用不同的实现，这时接口变量就呈现不同的形态。

5.3.2、快速入门案例（复用了6.1.3的案例）

package main

import "fmt"

// 定义一个接口
type Usb interface {
	// 接口内定义2个方法
	Start()
	Stop()
}

// 定义结构体Phone
type Phone struct {
}
// 结构体Phone的Start方法
func (p Phone) Start() {
	fmt.Println("phone start")
}
// 结构体Phone的Stop方法
func (p Phone) Stop() {
	fmt.Println("phone Stop")
}

// 定义结构体Camera
type Camera struct {
}
// 结构体Camera的Start方法
func (c Camera) Start() {
	fmt.Println("camera start")
}
// 结构体Camera的Stop方法
func (c Camera) Stop() {
	fmt.Println("camera Stop")
}

// 定义结构体Computer
type Computer struct {
}
// 结构体Computer的Working方法，"接收参数"的类型为Usb(interface)
// Usb内有2个方法"Start"和"Stop"：只要结构体也绑定了"Start"和"Stop"方法，那么这个结构体实现了"Usb接口"。
func (computer Computer) Working(usb Usb) {
	// 这里的usb就是一种"多态"。usb的值就是传递过来的"结构体变量"，会去判断导致是camera还是phone。
	// 通过传递过来的"结构体变量"调用方法
	usb.Start()
	usb.Stop()
}

func main() {
	// 结构体变量
	computer := Computer{}
	camera := Camera{}
	phone := Phone{}

	// 调用方法
	computer.Working(phone)  // 返回值：phone start，phone stop
	computer.Working(camera)  // 返回值：camera start，camera stop
}

5.3.3、接口体现的"多态特性"

多态参数：上述入门案例，体现了多态参数（computer.Working方法，既可以接收phone变量，又可以接收camera变量，体现了Usb接口的多态）

多态数组，案例如下（在一个数组中，存放Phone结构体和Camera结构体，这两个结构体是两种不同类型）

package main

import "fmt"

// 定义一个接口
type Usb interface {
	// 接口内定义2个方法
	Start()
	Stop()
}

// 定义结构体Phone
type Phone struct {
	Name string
}
// 结构体Phone的Start方法
func (p Phone) Start() {
	fmt.Println("phone start")
}
// 结构体Phone的Stop方法
func (p Phone) Stop() {
	fmt.Println("phone Stop")
}

// 定义结构体Camera
type Camera struct {
	Name string
}
// 结构体Camera的Start方法
func (c Camera) Start() {
	fmt.Println("camera start")
}
// 结构体Camera的Stop方法
func (c Camera) Stop() {
	fmt.Println("camera Stop")
}

// 定义结构体Computer
type Computer struct {}
// 结构体Computer的Working方法，"接收参数"的类型为Usb(interface)
// Usb内有2个方法"Start"和"Stop"：只要结构体也绑定了"Start"和"Stop"方法，那么这个结构体实现了"Usb接口"。
func (computer Computer) Working(usb Usb) {
	// 这里的usb就是一种"多态"。usb的值就是传递过来的"结构体变量"，会去判断导致是camera还是phone。
	// 通过传递过来的"结构体变量"调用方法
	usb.Start()
	usb.Stop()
}

func main() {
	// 定义一个Usb接口数组，可以存放Phone和Camera的结构体变量
	// 可以体现出多态数组
	var usbArr [2]Usb
	usbArr[0] = Phone{
		Name: "iphone",
	}
	usbArr[1] = Camera{
		Name: "jianeng",
	}
	fmt.Println(usbArr)  // 返回值：[{iphone} {jianeng}]
}

5.3.4、类型断言（判断一个变量是否属于某个类型）

1.什么是类型断言？

    由于接口是一般类型，不知道具体类型，如果要转成具体类型，需要使用类型断言（在进行类型断言时，如果类型不匹配，就会报错）

案例1：

package main

import "fmt"

type Point struct {
	Name string
}

func main() {
	var a interface{}
	var point Point = Point{Name: "x"}
	a = point
	// 如何将a赋值给b变量
	var b Point
	// b = a 这样赋值会报错
	b = a.(Point)  // 类型断言
	fmt.Println(b)
	// b = a.(Point)就是类型断言，表示判断变量a的值是否属于'Point结构体类型'， 如果是则转成'Point结构体的变量'并赋值给b，否则报错。
}

案例2：

package main

import "fmt"

func main() {
	var x interface{}
	var b float32 = 1.1
	x = b
	fmt.Println(x)  // 返回值：1.1
	// 方式1：
	// y := x.(float32)
	// 方式2：
	y := x
	fmt.Println(y)  // 返回值：1.1
}

2.在类型断言时，附带检查机制（失败时提示错误信息，而不是panic）

package main

import "fmt"

func main() {
	var x interface{}
	var b float32 = 1.1
	x = b
	fmt.Println(x)  // 返回值：1.1

	// 类型断言检测机制(ok是一个bool类型)
	//y,ok := x.(float64)
	//if ok {
	//	fmt.Println("类型断言成功")
	//} else {
	//	fmt.Println("类型断言失败",y)
	//}

	// if判断-简洁版
	if y, ok := x.(float64); ok {
		fmt.Println("类型断言成功")
	} else {
		fmt.Println("类型断言失败", y)  // 类型断言失败 0
	}
}

5.3.5、类型断言的案例1

需求：Phone结构体有一个Call方法，遍历Usb数组，如果是phone变量则调用Call方法

package main

import (
	"fmt"
)

// 定义一个接口
type Usb interface {
	// 接口内定义2个方法
	Start()
	Stop()
}

// 定义结构体Phone
type Phone struct {
	Name string
}
// 结构体Phone的Start方法
func (p Phone) Start() {
	fmt.Println("phone start")
}
// 结构体Phone的Stop方法
func (p Phone) Stop() {
	fmt.Println("phone Stop")
}
// 结构体Phone的Call方法
func (p Phone) Call() {
	fmt.Println("phone Call")
}

// 定义结构体Camera
type Camera struct {
	Name string
}
// 结构体Camera的Start方法
func (c Camera) Start() {
	fmt.Println("camera start")
}
// 结构体Camera的Stop方法
func (c Camera) Stop() {
	fmt.Println("camera Stop")
}

// 定义结构体Computer
type Computer struct {}
// 结构体Computer的Working方法，"接收参数"的类型为Usb(interface)
// Usb内有2个方法"Start"和"Stop"：只要结构体也绑定了"Start"和"Stop"方法，那么这个结构体实现了"Usb接口"。
func (computer Computer) Working(usb Usb) {
	// 通过参数usb(也就是Usb接口)去调用"Start"和"Stop"方法
	usb.Start()
	usb.Stop()
}

func main() {
	var usbArr [2]Usb
	usbArr[0] = Phone{"iphone"}
	usbArr[1] = Camera{"jianeng"}

	// Phone结构体有一个Call方法，遍历Usb数组，如果是phone变量则调用Call方法
	var computer Computer
	for _ ,v := range usbArr {
		// 使用类型断言，判断变量v的值是否属于"Phone结构体类型"如果是则调用"Phone结构体"的Call方法
		if p, ok := v.(Phone); ok{
			p.Call()  // 返回值：phone Call
		}
		computer.Working(v) // 返回值如下：
		//phone start
		//phone Stop
		//camera start
		//camera Stop
	}
}

5.3.6、类型断言的案例2

写一个函数，循环判断传入参数的类型

package main

import "fmt"

// 函数TypeJudge接收的参数是一个"空接口"(可以接收任意变量)
// 用来判断一个"实参"具体的类型
func TypeJudge(item ...interface{})  {
	for _,v := range item {
		// v.(type)：这里的type是一个关键字，固定写法
		switch v.(type) {
		case bool:
			fmt.Println("这是一个,bool,类型,值为: ",v)
		case float64:
			fmt.Println("这是一个,float64,类型,值为: ",v)
		case int:
			fmt.Println("这是一个,int,类型,值为: ",v)
		case nil:
			fmt.Println("这是一个,nil,类型,值为: ",v)
		case string:
			fmt.Println("这是一个,string,类型,值为: ",v)
		case Student:
			fmt.Println("这是一个,Student,类型,值为: ",v)
		case *Student:
			fmt.Println("这是一个,*Student,类型,值为: ",v)
		default:
			fmt.Println("未知类型,类型,值为: ",v)
		}
	}
}

// 结构体Student
type Student struct {}

func main() {
	name := "sudada"
	TypeJudge(name)  // 返回值：这是一个,string,类型,值为:  sudada
	age := 18
	TypeJudge(age)  // 这是一个,int,类型,值为:  18
	num := 1.8
	TypeJudge(num)  // 这是一个,float64,类型,值为:  1.8
	status := true
	TypeJudge(status)  // 这是一个,bool,类型,值为:  true
	// 结构体变量类型1
	student1 := Student{}
	TypeJudge(student1)  // 这是一个,Student,类型,值为: {}
	// 结构体变量类型2
	student2 := &Student{}
	TypeJudge(student2)  // 这是一个,*Student,类型,值为: &{}
}

六、面向对象-接口（interface）非常重要★★★★★★

6.1、接口的介绍和快速入门

6.1.1、接口语法

type 接口名 interface {
    方法1(参数名 类型) (返回值名 返回值类型)
    方法2(参数名 类型) (返回值名 返回值类型)
}

6.1.2、接口介绍

        1.接口可以定义多个方法，但是不需要具体实现。（只有名称没有代码逻辑），高聚合，松耦合。

        2.接口不能包含任何变量。

        3.结构体在使用接口时，编写接口同名方法的具体实现逻辑。只要结构体包含了接口所有的方法，那么结构体就实现了这个接口。（ 结构体的方法名和接口的方法名一致时，结构体就实现了接口。案例如下：）

package main

import "fmt"

// 定义一个接口
type Usb interface {
	// 接口内定义2个方法
	Start()
	Stop()
}

// 定义结构体Phone
type Phone struct {
}
// 结构体Phone的Start方法
func (p Phone) Start() {
	fmt.Println("phone start")
}
// 结构体Phone的Stop方法
func (p Phone) Stop() {
	fmt.Println("phone Stop")
}

// 那么"结构体Phone"就实现了"接口Usb"

6.1.3、接口快速入门案例

package main

import "fmt"

// 定义一个接口
type Usb interface {
	// 接口内定义2个方法
	Start()
	Stop()
}

// 定义结构体Phone
type Phone struct {
}
// 结构体Phone的Start方法
func (p Phone) Start() {
	fmt.Println("phone start")
}
// 结构体Phone的Stop方法
func (p Phone) Stop() {
	fmt.Println("phone Stop")
}

// 定义结构体Camera
type Camera struct {
}
// 结构体Camera的Start方法
func (c Camera) Start() {
	fmt.Println("camera start")
}
// 结构体Camera的Stop方法
func (c Camera) Stop() {
	fmt.Println("camera Stop")
}

// 定义结构体Computer
type Computer struct {
}
// 结构体Computer的Working方法，"接收参数"的类型为Usb(interface)
// Usb内有2个方法"Start"和"Stop"：只要结构体也绑定了"Start"和"Stop"方法，那么这个结构体实现了"Usb接口"。
func (computer Computer) Working(usb Usb) {
	// 这里的usb就是一种"多态"。usb的值就是传递过来的"结构体变量"，会去判断导致是camera还是phone。
	// 通过传递过来的"结构体变量"调用方法
	usb.Start()
	usb.Stop()
}

func main() {
	// 结构体变量
	computer := Computer{}
	camera := Camera{}
	phone := Phone{}

	// 调用方法
	computer.Working(phone)  // 返回值：phone start，phone stop
	computer.Working(camera)  // 返回值：camera start，camera stop
}

6.2、接口的注意事项

6.2.1、接口本身不能创建实例，但是可以指向一个已经实现了该接口的变量。

package main

import "fmt"

// 接口A，有一个Say方法
type A interface {
	Say()
}

// 结构体Student实现了A接口
type Student struct {
	Name string
}
func (stu Student) Say()  {
	fmt.Println(stu.Name)
}

func main() {
	// Student结构体变量stu
	var stu = Student{Name: "sudada"}
	// 结构体Student只有实现了A接口，才可以这么赋值
	var a A = stu
	a.Say()  // 返回值：sudada
}

6.2.2、接口中所有的方法，只有名称，没有具体代码实现过程。

6.2.3、"结构体"或"自定义类型"，需要将一个接口内的所有方法都实现，才能叫做实现了该接口。

6.2.4、只需要是"自定义的数据类型"，都可以实现接口。不仅仅是"结构体类型"。

6.2.5、自定义类型可以实现多个接口（多个接口内可以有同名的方法）

package main

import "fmt"

// 接口A，有一个Say方法
type A interface {
	Say()
}
// 接口B，有一个Hello方法
type B interface {
	Hello()
}

// 结构体Student实现了A接口和B接口
type Student struct {
	Name string
}
func (stu Student) Say()  {
	fmt.Println("Say")
}
func (stu Student) Hello()  {
	fmt.Println("Hello")
}

func main() {
	var stu = Student{}
	// 调用A接口的方法Say
	stu.Say()  // 返回值：Say
	// 调用B接口的方法Hello
	stu.Hello()  // 返回值：Hello
}

6.2.6、Golang接口中不能有任何变量。

6.2.7、一个"接口A"如果继承了"B,C接口"，那么要"实现A接口"，就必须将B,C接口全部实现。

package main

import "fmt"

// 接口B，有一个Hello方法
type B interface {
	Hello()
}
// 接口C，有一个Hai方法
type C interface {
	Hai()
}
// 接口A，有一个Say方法，同时继承B,C接口
type A interface {
	B
	C
	Say()
}


// 结构体Student实现了A接口(同时必须实现B,C接口)
type Student struct {
	Name string
}
func (stu Student) Say()  {
	fmt.Println("Say")
}
func (stu Student) Hai()  {
	fmt.Println("Hai")
}
func (stu Student) Hello()  {
	fmt.Println("Hello")
}

func main() {
	var stu = Student{}
	// 只有结构体Student将A接口(继承B,C接口)的所有方法都实现，才能这么使用
	var a A = stu
	a.Say()  // 返回值：Say
	a.Hai()  // 返回值：Hai
	a.Hello()  // 返回值：Hello
}

6.2.8、接口"interface"默认是一个指针(引用类型)，如果没有对接口"interface"初始化就使用，默认会返回nil（详见6.1.3案例）

6.2.9、空接口"interface{}"没有任何的方法，所以所有类型都实现了空接口"interface{}"（可以把任何一个变量赋值给空接口"interface{}"），空接口"interface{}"也是一种类型。

import "fmt"

// 接口A
type A interface {
}
// 结构体Student
type Student struct {
	Name string
}

func main() {
	// "空接口"的使用方式1
	var stu = Student{}
	// 接口A没有任何方法(空接口)，那么就可以把任意变量赋值给空接口
	var a A = stu
	fmt.Println(a)  // 返回值：{}

	// "空接口"的使用方式2
	// 变量test是一个"空接口"类型，赋值为"test"
	var test interface{} = "test"
	fmt.Println(test)  // 返回值：test
	
	// 变量test2是一个"空接口"类型，赋值为变量num
	var num int = 122
	var test2 interface{} = num
	fmt.Println(test2)  // 返回值：122
}

6.3、接口的案例（对"切片"的内容进行排序）

package main

import (
	"fmt"
	"math/rand"
	"sort"
)

// 定义结构体Hero
type Hero struct {
	Name string
	Age int
}
// 定义结构体切片HeroSlice
type HeroSlice []Hero

// 结构体Hero实现接口（绑定接口的方法）
// Len方法，返回结构体的长度
func (hs HeroSlice) Len() int {
	return len(hs)
}
// Less方法，决定使用怎样的方式进行排序
func (hs HeroSlice) Less(i,j int) bool {
	// 从小到大排序Age
	return hs[i].Age < hs[j].Age
	// 从大到小排序Age
	// return hs[i].Age > hs[j].Age
}
// Swap方法
func (hs HeroSlice) Swap(i,j int) {
	// a,b 两个变量交换值(a=b,b=a)，方法1
	//temp := hs[i]
	//hs[i] = hs[j]
	//hs[j] = temp

	// a,b 两个变量交换值(a=b,b=a)，方法2
	hs[i],hs[j] = hs[j],hs[i]
}

func main() {
	// 定义一个切片
	var test = []int{0,10,20,90,40}
	// 对切片排序，方式2（sort排序）
	sort.Ints(test)
	fmt.Println(test) // 返回值：[0 10 20 40 90]

	// "结构体切片"进行排序
	// 定义结构体变量heros
	var heros HeroSlice
	// 生成一些随机值h
	for i:=0;i<=10;i++{
		h := Hero{
			Name: fmt.Sprintf("英雄~%d",rand.Intn(100)),
			Age: rand.Intn(100),
		}
		// 将h的值append到结构体变量heros中去
		heros = append(heros, h)
	}
	fmt.Println(heros) // 返回值：[{英雄~13 25} {英雄~33 47} {英雄~64 31} {英雄~29 73} {英雄~67 2} {英雄~90 50} {英雄~41 48} {英雄~50 48} {英雄~18 5} {英雄~70 95} {英雄~88 33}]

	// 排序前heros的顺序
	for _,v := range heros {
		fmt.Println("-------排序前-------")
		fmt.Println(v)
	}

	// 调用sort.Sort进行排序
	sort.Sort(heros)
	fmt.Println("-------按照年龄排序后-------")
	for _,v := range heros {
		fmt.Println(v)
	}
}

七、接口和继承的比较

7.1、继承和接口解决的问题不同

1、继承主要解决代码的复用性和可维护性。

2、接口主要在于设计好各种规范(方法)，让其他自定义类型去实现这些方法。

3、接口比继承更灵活，同时一定程度实现代码解耦。

7.2、简单的小案例说明

1、B结构体继承A结构体时，就自动继承了A结构体的字段和方法，并且可以直接使用。

2、B结构体需要扩展功能同时又不希望去修改继承关系时(不改变A结构体的字段和方法)，则使用接口(实现接口，是对继承机制的一种补充)

package main

import "fmt"

// 结构体Monkey
type Monkey struct {
	Name string
}
// 结构体Monkey绑定的方法
func (m Monkey) pashu()  {
	fmt.Println(m.Name,"继承了爬树的技能...")
}
// 结构体LittleMonkey继承Monkey
type LittleMonkey struct {
	Monkey
}

// 接口
type Fly interface {
	fly()
}
type Swim interface {
	swimming()
}
// 结构体LittleMonkey实现接口Fly
func (m LittleMonkey) fly()  {
	fmt.Println(m.Name,"学会了飞行...")
}
// 结构体LittleMonkey实现接口Swim
func (m LittleMonkey) swimming()  {
	fmt.Println(m.Name,"学会了游泳...")
}

func main() {
	ddd := LittleMonkey{
		Monkey{Name: "悟空"},
	}
	ddd.pashu()  // 返回值：悟空 继承了爬树的技能...
	ddd.fly()  // 返回值：悟空 学会了飞行...
	ddd.swimming()  // 返回值：悟空 学会了游泳...
}

七、面向对象-例子

7.1、例子1：写一个方法，输出对象的所有信息

package main

import "fmt"

type Student struct {
	Name string
	gender string
	age int
	id int
	score float64
}

func (stu *Student)say() string {
	stuInfo := fmt.Sprintf(
		"%v\n%v\n%v\n%v\n%v",
		stu.Name,
		stu.gender,
		stu.age,
		stu.id,
		stu.score,
		)
	return stuInfo
}

func main() {
	var stu Student = Student{
		Name: "sudada",
		gender: "male",
		age: 18,
		id: 01,
		score: 100,
	}
	fmt.Println(stu.say())
	// sudada
	// male
	// 18
	// 1
	// 100
}