struct 结构体（类似 POJO）

定义

type Person struct {
	name string
	age  int
}

func main() {
	var person1 Person
	person1.name = "张三"
	person1.age = 18

	person2 := Person{
		name: "李四",
		age:  20,
	}

	person3 := Person{"王五", 22}

	fmt.Println(person1)
	fmt.Println(person2)
	fmt.Println(person3)
}

封装

type Person struct {
	name string
	age  int
}

func (this *Person) GetName() string {
	return this.name
}

func (this *Person) GetAge() int {
	return this.age
}

func (this *Person) SetName(name string) {
	this.name = name
}

func (this *Person) SetAge(age int) {
	this.age = age
}

命名规范

• 类名、方法名、属性名首字母大写，表示 public
• 类名、方法名、属性名首字母小写，表示 private

继承

// 定义Person类
type Person struct {
	name string
	age  int
}

func (this *Person) Eat() {
	fmt.Println("吃饭")
}

func (this *Person) Sleep() {
	fmt.Println("睡觉")
}


// 定义Student类
type Student struct {
	Person // 表示继承Person
	score int
}

func (this *Student) Study() {
	fmt.Println("学习")
}

// 重写
func (this *Student) Sleep() {
	fmt.Println("学生睡觉")
}


func main() {
	// 声明方式1
	var student Student
	student.name = "张三"
	student.age = 18
	student.score = 100

	// 声明方式2
	student2 := Student{
		Person: Person{
			name: "李四",
			age:  20,
		},
		score: 99,
	}

	fmt.Println(student)
	student.Eat()
	student.Sleep()
}

多态

基于接口实现多态

// 定义AnimalIF接口，本质上是一个指针
type AnimalIF interface {
	Sleep()
	GetName() string
}

// 定义Dog类
type Dog struct {
	name string
}

func (this *Dog) Sleep() {
	fmt.Println("狗睡觉")
}

func (this *Dog) GetName() string {
	return this.name
}

// 定义Cat类
type Cat struct {
	name string
}

func (this *Cat) Sleep() {
	fmt.Println("猫睡觉")
}

func (this *Cat) GetName() string {
	return this.name
}

func main() {
	var animal AnimalIF
	animal = &Dog{"旺财"}
	animal.Sleep()
	fmt.Println(animal.GetName())

	animal = &Cat{"小花"}
	animal.Sleep()
	fmt.Println(animal.GetName())
}

接口的实现

• 只要实现了接口中的所有方法，就实现了该接口，不需要显式声明实现了哪个接口
• 如果只实现了接口中的部分方法，那么该类就没有实现该接口，赋值给该接口的变量会报错

interface 接口

通用万能类型（类似 Object）

func main() {
	var a interface{}
	a = 10
	fmt.Println(a)

	a = "hello"
	fmt.Println(a)

	a = true
	fmt.Println(a)

	a = Person{"张三", 18}
	fmt.Println(a)
}

类型断言

func main() {
	var a interface{}
	a = 10
	fmt.Println(a)

	// 类型断言
	value, ok := a.(int)
	if ok {
		fmt.Println(value)
	} else {
		fmt.Println("类型断言失败")
	}
}

• 类型断言的本质是类型转换
• 类型断言的结果是两个值，第一个值是转换后的值，第二个值是转换是否成功