Go语言简易的面向对象之结构体和从此突破指针

go的面向对象

结构体定义

type 结构体名称 struct{
field1 type
field2 type
}
结构体名称若为大写，则其他包也能引用该结构体

指针，slice，map的零值都为nil，
slice和map使用前必须make

结构体的声明（4种方式）

1. var student1 Student
2. var student2 Student = Student{
   “李威彤”,20,
   }
3. var student3 *Student = new(Student)
4. var student4 *Student = &Student{“tom”,11}

package main
import(
	"fmt"
)

func main(){
	// 1
	var student1 Student
	student1.Name="李威彤1"
	student1.Age=22
	fmt.Println(student1)

	// 2
	var student2 Student = Student{
		"李威彤",20,
	}
	fmt.Println(student2)

	// 3 返回的是结构体指针，go作简化后，支持结构体指针.字段名，原本其实是(*结构体指针).属性
	var student3 *Student = new(Student)
	// (*student3).Name = "郑敏艺"
	// (*student3).Age = 21
	student3.Name = "郑敏艺"
	student3.Age = 21
	fmt.Println(*student3) // 这里的星号不加会出现取地址符号

	// 4 返回的是结构体指针，go作简化后，支持结构体指针.字段名，原本其实是(*结构体指针).属性
	var student4 *Student = &Student{"tom",11}
	fmt.Println(*student4)
}

type Student struct{
	Name string
	Age int
}

结构体强转

	var student1 Stu
	var student2 Student
	// student1的数据类型是Stu，Stu只是Student的别名，这两者golang不等价！
	student2 = Student(student1) // 必须强转
	fmt.Println(student1,student2)
}
type Student struct{
	Name string
}
type Stu Student // 给Student自定义数据类型起别名

	var i integer = 10 // integer只是int的别名，并不等价
	var j int = 20
	j = int(i)
	fmt.Println(i,j)
}
// 第二个实例：结构体强转
type integer int

结构体转json格式的字符串，返回给前端以便处理和分离

package main

import(
	"fmt"
	"encoding/json"
)

func main(){
	monster1 := Monster{"李威彤",21}
	fmt.Println(monster1)

	jsonString,_:=json.Marshal(monster1)

	// 实际场景，字段首字母为小写。如何解决，字段使用标签``，即反射机制
	fmt.Println("服务端将会收到json格式的字符串=>",string(jsonString))
// 服务端将会收到json格式的字符串=> {"name":"李威彤"}
}

type Monster struct{
	Name string `json:"name"` // 返回的json格式的字符串中的首字母小写name
	age int `json:"age"`
}

声明结构体指定字段名

var stu5 *Stu= &Stu{"小李",22} // stu -> 地址 -> 结构体数据

	// 1 不可颠倒顺序
	var stu1 = Stu{"小明",19}
	stu2:=Stu{"小明~",20}

	// 2 不依赖顺序
	var stu3 = Stu{
		Name:"jack",
		Age:20,
	}

	stu4:=Stu{
		Age:30,
		Name:"mary",
	}
	fmt.Println(stu1)
	fmt.Println(stu2)
	fmt.Println(stu3)
	fmt.Println(stu4)

	// 3 将结构体的指针返回给一个变量.返回结构体的指针类型！
	var stu5 *Stu= &Stu{"小李",22} // stu -> 地址 -> 结构体数据
	stu6 := &Stu{"小李~",23}
	fmt.Println(*stu5)
	fmt.Println(*stu6)

	// 4 
	var stu7 = &Stu{
		Name : "小郑",
		Age:20,
	}

	stu8 := &Stu{
		Name : "小郑~",
		Age:21,
	}
	fmt.Println(*stu7)
	fmt.Println(*stu8) // 不加*有&
}

type Stu struct{
	Name string
	Age int
}

突破！结构体内存图

p2这个指针所指的值为一个地址！p2本身也拥有一个地址，但也仅仅是仅限于用&p2打印出来看看罢了，p2的值（地址）就是p1的地址值（&p1），p1的值那自然就是一个对象拥有的属性元素啦！

{
	var person Person
	person.Age = 1
	var p2 *Person = &person
	fmt.Println((*p2).Age)
	fmt.Println(p2.Age) // 等同如上
	// 就是不能fmt.Println(*p2.Age)
}
type Person struct{
	Name string
	Age int
}