package main

import (
	"fmt"
)

// 1. 枚举与基础结构体定义

// 定义 Gender 枚举
type Gender uint8

const (
	FEMALE  Gender = iota // 0
	MALE                  // 1
	THIRD                 // 2
	UNKNOWN               // 3
)

// 2. 接口与多态的结构体定义

// Person 接口：只要实现了 Run 和 Sleep 方法，就是 Person
type Person interface {
	Run()
	Sleep()
}

// 定义 User 结构体
type User struct {
	Name   string
	Age    uint8
	Gender Gender
}

func (u *User) Run() {
	fmt.Println("user run")
}
func (u *User) Sleep() {
	fmt.Println("user sleep")
}

// 定义 Teacher 结构体
type Teacher struct {
	Name   string
	Age    uint8
	Gender Gender
}

func (t *Teacher) Run() {
	fmt.Println("在公园跑步")
}
func (t *Teacher) Sleep() {
	fmt.Println("在家睡觉")
}

// 定义 Student 结构体
type Student struct {
	// 字段省略
}

func (s *Student) Run() {
	fmt.Println("学生在操场跑步")
}
func (s *Student) Sleep() {
	fmt.Println("学生在宿舍睡觉")
}

// 3. 业务函数：多态与类型断言

// UserCase 测试基础方法调用
func UserCase() {
	fmt.Println("--- UserCase ---")
	u := &User{} // 返回指针
	u.Run()
	u.Sleep()
}

// PersonCase 测试多态与 defer 的场景
func PersonCase(person Person) {
	// defer 演示：无论方法如何，最后都会执行（在 return 之后）
	defer func() {
		fmt.Println("person defer")
	}()

	person.Run()
	person.Sleep()
	return
}

// PersonCase1 测试基于空接口 interface{} 的类型断言
func PersonCase1(person interface{}) {
	fmt.Println("--- PersonCase1 (Type Assertion) ---")
	// 断言：判断传入的参数是否实现了 Person 接口
	if p1, ok := person.(Person); ok {
		p1.Run()
	} else {
		fmt.Println("类型不能识别")
	}
}

// 4. 异常处理：Panic 与 Recover

func TryCatchCase() {
	fmt.Println("--- TryCatchCase ---")
	defer func() {
		err := recover() // 捕获异常
		if err != nil {
			fmt.Println("Recovered:", err)
		}
	}()
	PanicCase()
}

func PanicCase() {
	panic("程序出现异常了") // 触发异常
}

// 5. Defer 的进阶场景：传参 vs 闭包

func DeferCase() {
	fmt.Println("--- DeferCase (传参 vs 闭包) ---")
	i := 1

	// 传参：在声明时计算出参数值 i+1 = 2，放入 defer 栈中
	defer func(j int) {
		fmt.Println("defer j: ", j)
	}(i + 1)

	// 闭包：直接引用外部变量 i。执行时读取 i 的最终真实值
	defer func() {
		i++
		fmt.Println("defer i: ", i)
	}()

	i = 99
	return
	// j = 2, i = 100
}

// 6. Defer 的进阶场景：对返回值与外部变量的影响

var j int = 1

func DeferCase1() {
	fmt.Println("--- DeferCase1 (修改返回值) ---")
	i, i1 := f1()
	// 输出 f1返回的副本(i)、f1返回的指针指向的值(*i1)、外部变量(j)
	fmt.Println(i, *i1, j) 
	// i = 1, i1 = 100, j = 100
}

func f1() (int, *int) {
	defer func() {
		j = 100 // defer 会在 return 之后执行，修改了全局变量 j 的值
	}()
	fmt.Println("f1 j: ", j)
	// 第一个返回值是值拷贝（复制了 1），第二个返回值是指针（指向 j 的内存地址）
	return j, &j
}

// 主函数入口
func main() {
	// 1. 测试对象方法
	UserCase()

	// 2. 测试多态 (Teacher 和 Student 都实现了 Person 接口)
	fmt.Println("--- Polymorphism (多态) ---")
	t := &Teacher{}
	s := &Student{}
	PersonCase(t)
	PersonCase(s)

	// 3. 测试类型断言
	PersonCase1(t)             // 正常识别
	PersonCase1("hello world") // 无法识别

	// 4. 测试异常拦截
	TryCatchCase()

	// 5. 测试 Defer 顺序与闭包
	DeferCase()

	// 6. 测试 Defer 修改变量及指针现象
	DeferCase1()
}