update

golang-learn/15-pointers/pointers.go

@@ -1,6 +1,9 @@
 package main
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 /*
 swap(a, b *int) 这个函数可以把两个整数的值互换，但它需要这两个整数的“地址”（指针），这样它才能直接修改原始变量的值。
@@ -25,4 +28,24 @@ func main() {
 
 	swap(&x, &y) // 传入变量x、y的地址，实现交换
 	fmt.Printf("交换后 x=%d, y=%d\n", x, y)
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 88))
+
+	var a int = 20 // 声明实际变量
+	var ip *int    // 声明指针变量
+
+	ip = &a // 指针变量的存储地址
+
+	fmt.Printf("a 变量的地址是: %x\n", &a)
+
+	// 指针变量的存储地址
+	fmt.Printf("ip 变量储存的指针地址: %x\n", ip)
+
+	// 使用指针访问值
+	fmt.Printf("*ip 变量的值: %d\n", *ip)
+
+	// 空指针
+	var ptr *int
+	fmt.Printf("ptr 的值为: %x\n", ptr)
+	fmt.Printf("%x\n", &ptr)
 }

golang-learn/41-anonymous_function/anonymous_function.go

@@ -0,0 +1,34 @@
+package main
+
+import "fmt"
+
+func main() {
+	add := func(arr []int) int {
+		if arr == nil {
+			return 0
+		}
+		result := 0
+		for _, v := range arr {
+			result += v
+		}
+		return result
+	}
+
+	myArr := []int{3, 4, 7, 1, 7, 4, 8}
+
+	result := add(myArr)
+
+	result1 := func(arr []int) int {
+		if arr == nil {
+			return 0
+		}
+		result := 0
+		for _, v := range arr {
+			result += v
+		}
+		return result
+	}(myArr)
+
+	fmt.Println(result)
+	fmt.Println(result1)
+}

golang-learn/42-closure/closure.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func outer() func() int {
+	count := 0
+	return func() int {
+		count++
+		return count
+	}
+}
+
+func main() {
+	counter := outer()
+	fmt.Println(counter())
+	fmt.Println(counter())
+	fmt.Println(counter())
+
+	anotherCounter := outer()
+	fmt.Println(anotherCounter())
+	fmt.Println(anotherCounter())
+}

golang-learn/43-method/method.go

@@ -0,0 +1,126 @@
+package main
+
+import "fmt"
+
+/*
+// 普通函数
+func 函数名(参数) 返回值 {
+    // 函数体
+}
+
+// 方法 = 函数 + 接收者
+func (接收者) 方法名(参数) 返回值 {
+    // 方法体
+}
+*/
+
+// 游戏角色系统
+type Player struct {
+	Name      string
+	Level     int
+	Health    int
+	MaxHealth int
+	Attack    int
+}
+
+// 值接收器方法 - 只读操作
+func (p Player) DisplayStatus() {
+	fmt.Printf("=== %s的状态 ===\n", p.Name)
+	fmt.Printf("等级: %d\n", p.Level)
+	fmt.Printf("生命值: %d/%d\n", p.Health, p.MaxHealth)
+	fmt.Printf("攻击力: %d\n", p.Attack)
+}
+
+func (p Player) IsAlive() bool {
+	return p.Health > 0
+}
+
+// 指针接收器方法 - 修改状态
+func (p *Player) TakeDamage(damage int) {
+	p.Health -= damage
+	if p.Health < 0 {
+		p.Health = 0
+	}
+	fmt.Printf("%s受到%d点伤害！剩余生命值: %d\n", p.Name, damage, p.Health)
+}
+
+func (p *Player) Heal(amount int) {
+	p.Health += amount
+	if p.Health > p.MaxHealth {
+		p.Health = p.MaxHealth
+	}
+	fmt.Printf("%s恢复%d点生命值！当前生命值: %d\n", p.Name, amount, p.Health)
+}
+
+func (p *Player) LevelUp() {
+	p.Level++
+	p.MaxHealth += 20
+	p.Health = p.MaxHealth // 升级回满血
+	p.Attack += 5
+	fmt.Printf("%s升级了！现在等级: %d\n", p.Name, p.Level)
+}
+
+// 战斗方法
+func (p *Player) AttackTarget(target *Player) {
+	if !p.IsAlive() {
+		fmt.Printf("%s已经倒下，无法攻击！\n", p.Name)
+		return
+	}
+	if !target.IsAlive() {
+		fmt.Printf("%s已经倒下，无需攻击！\n", target.Name)
+		return
+	}
+
+	damage := p.Attack
+	fmt.Printf("%s攻击%s，造成%d点伤害！\n", p.Name, target.Name, damage)
+	target.TakeDamage(damage)
+}
+
+func main() {
+	fmt.Println("=== 游戏战斗演示 ===\n")
+
+	// 创建两个玩家
+	hero := &Player{
+		Name:      "勇者",
+		Level:     1,
+		Health:    100,
+		MaxHealth: 100,
+		Attack:    15,
+	}
+
+	monster := &Player{
+		Name:      "怪物",
+		Level:     1,
+		Health:    80,
+		MaxHealth: 80,
+		Attack:    12,
+	}
+
+	// 显示初始状态
+	hero.DisplayStatus()
+	monster.DisplayStatus()
+
+	fmt.Println("\n=== 战斗开始 ===")
+
+	// 第一轮攻击
+	hero.AttackTarget(monster)
+	monster.AttackTarget(hero)
+
+	// 第二轮攻击
+	hero.AttackTarget(monster)
+	monster.AttackTarget(hero)
+
+	// 勇者升级
+	fmt.Println("\n=== 勇者升级 ===")
+	hero.LevelUp()
+	hero.DisplayStatus()
+
+	// 最终攻击
+	fmt.Println("\n=== 最终攻击 ===")
+	hero.AttackTarget(monster)
+
+	// 检查存活状态
+	fmt.Printf("\n战斗结果:\n")
+	fmt.Printf("勇者存活: %t\n", hero.IsAlive())
+	fmt.Printf("怪物存活: %t\n", monster.IsAlive())
+}

golang-learn/44-interface1/main.go

@@ -0,0 +1,232 @@
+package main
+
+import "fmt"
+
+// ========== 接口定义 ==========
+// 支付接口 - 定义支付行为契约
+type Payment interface {
+	Pay(amount float64) bool
+	Refund(amount float64) bool
+	GetBalance() float64
+	GetProviderName() string
+}
+
+// ========== 结构体定义 ==========
+// 支付宝支付
+type Alipay struct {
+	Account string
+	Balance float64
+}
+
+// 微信支付
+type WechatPay struct {
+	OpenID  string
+	Balance float64
+	Frozen  float64 // 冻结金额
+}
+
+// 银行卡支付
+type BankCard struct {
+	CardNumber string
+	Balance    float64
+	BankName   string
+}
+
+// ========== 方法实现 - Alipay ==========
+func (a *Alipay) Pay(amount float64) bool {
+	if amount <= 0 || amount > a.Balance {
+		fmt.Printf("支付宝支付失败！金额: %.2f, 余额: %.2f\n", amount, a.Balance)
+		return false
+	}
+	a.Balance -= amount
+	fmt.Printf("支付宝支付成功！扣款: %.2f, 剩余余额: %.2f\n", amount, a.Balance)
+	return true
+}
+
+func (a *Alipay) Refund(amount float64) bool {
+	if amount <= 0 {
+		return false
+	}
+	a.Balance += amount
+	fmt.Printf("支付宝退款成功！退款: %.2f, 当前余额: %.2f\n", amount, a.Balance)
+	return true
+}
+
+func (a Alipay) GetBalance() float64 {
+	return a.Balance
+}
+
+func (a Alipay) GetProviderName() string {
+	return "支付宝"
+}
+
+// ========== 方法实现 - WechatPay ==========
+func (w *WechatPay) Pay(amount float64) bool {
+	available := w.Balance - w.Frozen
+	if amount <= 0 || amount > available {
+		fmt.Printf("微信支付失败！金额: %.2f, 可用余额: %.2f\n", amount, available)
+		return false
+	}
+	w.Balance -= amount
+	fmt.Printf("微信支付成功！扣款: %.2f, 剩余余额: %.2f\n", amount, w.Balance)
+	return true
+}
+
+func (w *WechatPay) Refund(amount float64) bool {
+	if amount <= 0 {
+		return false
+	}
+	w.Balance += amount
+	fmt.Printf("微信退款成功！退款: %.2f, 当前余额: %.2f\n", amount, w.Balance)
+	return true
+}
+
+func (w WechatPay) GetBalance() float64 {
+	return w.Balance
+}
+
+func (w WechatPay) GetProviderName() string {
+	return "微信支付"
+}
+
+// 微信特有方法（不在接口中）
+func (w *WechatPay) FreezeAmount(amount float64) {
+	w.Frozen += amount
+	fmt.Printf("冻结金额: %.2f, 总冻结: %.2f\n", amount, w.Frozen)
+}
+
+func (w *WechatPay) UnfreezeAmount(amount float64) {
+	if amount <= w.Frozen {
+		w.Frozen -= amount
+		fmt.Printf("解冻金额: %.2f, 剩余冻结: %.2f\n", amount, w.Frozen)
+	}
+}
+
+// ========== 方法实现 - BankCard ==========
+func (b *BankCard) Pay(amount float64) bool {
+	if amount <= 0 || amount > b.Balance {
+		fmt.Printf("银行卡支付失败！金额: %.2f, 余额: %.2f\n", amount, b.Balance)
+		return false
+	}
+	b.Balance -= amount
+	fmt.Printf("银行卡支付成功！扣款: %.2f, 剩余余额: %.2f\n", amount, b.Balance)
+	return true
+}
+
+func (b *BankCard) Refund(amount float64) bool {
+	if amount <= 0 {
+		return false
+	}
+	b.Balance += amount
+	fmt.Printf("银行卡退款成功！退款: %.2f, 当前余额: %.2f\n", amount, b.Balance)
+	return true
+}
+
+func (b BankCard) GetBalance() float64 {
+	return b.Balance
+}
+
+func (b BankCard) GetProviderName() string {
+	return b.BankName + "银行卡"
+}
+
+// ========== 工具函数（使用接口） ==========
+// 处理支付 - 接受任何实现 Payment 接口的类型
+func ProcessPayment(p Payment, amount float64) bool {
+	fmt.Printf("\n开始处理支付...\n")
+	fmt.Printf("支付方式: %s\n", p.GetProviderName())
+	fmt.Printf("当前余额: %.2f\n", p.GetBalance())
+
+	success := p.Pay(amount)
+
+	if success {
+		fmt.Printf("✅ 支付处理完成\n")
+	} else {
+		fmt.Printf("❌ 支付处理失败\n")
+	}
+
+	return success
+}
+
+// 批量支付处理
+func ProcessBatchPayments(payments []Payment, amount float64) {
+	fmt.Printf("\n=== 批量支付处理 ===\n")
+	successCount := 0
+
+	for i, payment := range payments {
+		fmt.Printf("\n第 %d 笔支付:\n", i+1)
+		if ProcessPayment(payment, amount) {
+			successCount++
+		}
+	}
+
+	fmt.Printf("\n批量支付结果: 成功 %d/%d\n", successCount, len(payments))
+}
+
+// 检查支付方式状态
+func CheckPaymentStatus(payments []Payment) {
+	fmt.Printf("\n=== 支付方式状态检查 ===\n")
+	for i, payment := range payments {
+		fmt.Printf("%d. %s - 余额: %.2f\n",
+			i+1, payment.GetProviderName(), payment.GetBalance())
+	}
+}
+
+func main() {
+	fmt.Println("=== 支付系统演示 ===\n")
+
+	// 创建不同的支付实例
+	alipay := &Alipay{Account: "zhangsan@alipay.com", Balance: 1000.0}
+	wechat := &WechatPay{OpenID: "wx123456", Balance: 800.0}
+	bankcard := &BankCard{CardNumber: "622588******1234", Balance: 5000.0, BankName: "招商银行"}
+
+	// 演示微信特有方法
+	wechat.FreezeAmount(200.0)
+
+	// 将不同支付方式放入接口切片（多态）
+	payments := []Payment{alipay, wechat, bankcard}
+
+	// 1. 检查状态
+	CheckPaymentStatus(payments)
+
+	// 2. 单笔支付处理
+	fmt.Println("\n=== 单笔支付演示 ===")
+	ProcessPayment(alipay, 150.0)
+	ProcessPayment(wechat, 100.0) // 注意：微信有冻结金额
+
+	// 3. 批量支付处理
+	ProcessBatchPayments(payments, 50.0)
+
+	// 4. 退款演示
+	fmt.Println("\n=== 退款演示 ===")
+	alipay.Refund(50.0)
+	wechat.Refund(30.0)
+
+	// 5. 最终状态检查
+	CheckPaymentStatus(payments)
+
+	// 6. 类型断言演示：访问具体类型的特有方法
+	fmt.Println("\n=== 类型断言访问特有方法 ===")
+	for _, payment := range payments {
+		// 检查是否是 WechatPay 类型
+		if wechatPay, ok := payment.(*WechatPay); ok {
+			fmt.Printf("发现微信支付，冻结金额: %.2f\n", wechatPay.Frozen)
+			wechatPay.UnfreezeAmount(100.0) // 解冻部分金额
+		}
+	}
+
+	// 7. 类型切换演示
+	fmt.Println("\n=== 类型切换演示 ===")
+	for i, payment := range payments {
+		switch p := payment.(type) {
+		case *Alipay:
+			fmt.Printf("%d. 支付宝账户: %s\n", i+1, p.Account)
+		case *WechatPay:
+			fmt.Printf("%d. 微信OpenID: %s, 冻结金额: %.2f\n", i+1, p.OpenID, p.Frozen)
+		case *BankCard:
+			fmt.Printf("%d. 银行卡号: %s\n", i+1, p.CardNumber)
+		default:
+			fmt.Printf("%d. 未知支付类型\n", i+1)
+		}
+	}
+}

golang-learn/45-arrays1/main.go

@@ -0,0 +1,26 @@
+package main
+
+import "fmt"
+
+func main() {
+	var i, j, k int
+	// 声明数组的同时快速初始化数组
+	balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
+
+	/* 输出数组元素 */
+	for i = 0; i < 5; i++ {
+		fmt.Printf("balance[%d] = %f\n", i, balance[i])
+	}
+
+	balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
+	/* 输出每个数组元素的值 */
+	for j = 0; j < 5; j++ {
+		fmt.Printf("balance2[%d] = %f\n", j, balance2[j])
+	}
+
+	//  将索引为 1 和 3 的元素初始化
+	balance3 := [5]float32{1: 2.0, 3: 7.0}
+	for k = 0; k < 5; k++ {
+		fmt.Printf("balance3[%d] = %f\n", k, balance3[k])
+	}
+}

golang-learn/46-multidimensional_array/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	// Step 1: 创建数组
+	values := [][]int{}
+
+	// Step 2: 使用 append() 函数向空的二维数组添加两行一维数组
+	row1 := []int{1, 2, 3}
+	row2 := []int{4, 5, 6}
+	values = append(values, row1)
+	values = append(values, row2)
+
+	// Step 3: 显示两行数据
+	fmt.Println("Row 1")
+	fmt.Println(values[0])
+	fmt.Println("Row 2")
+	fmt.Println(values[1])
+
+	// Step 4: 访问第一个元素
+	fmt.Println("第一个元素为：")
+	fmt.Println(values[0][0])
+
+	fmt.Println(strings.Repeat("*", 88))
+
+	for _, v := range values {
+		for _, v1 := range v {
+			fmt.Println(v1)
+		}
+	}
+}

golang-learn/47-pointersArray/main.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+const MAX int = 3
+
+func main() {
+	a := []int{10, 100, 200}
+
+	for i := 0; i < MAX; i++ {
+		fmt.Printf("a[%d] = %d\n", i, a[i])
+	}
+
+	var ptr [MAX]*int
+
+	for i := 0; i < MAX; i++ {
+		ptr[i] = &a[i] // 整数地址赋值给指针数组
+	}
+
+	for i := 0; i < MAX; i++ {
+		fmt.Printf("a[%d] = %d\n", i, *ptr[i])
+	}
+}

golang-learn/48-range/range.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
+
+var str = "hello"
+
+var map1 = make(map[int]float32)
+
+func main() {
+	// 遍历数组
+	for i, v := range pow {
+		fmt.Printf("2**%d = %d\n", i, v)
+	}
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 100))
+
+	// 遍历字符串
+	for i, v := range str {
+		fmt.Printf("遍历字符串, 下标 %d, 值 %c\n", i, v)
+	}
+
+	map1[1] = 1.0
+	map1[2] = 2.0
+	map1[3] = 3.0
+	map1[4] = 4.0
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 100))
+
+	// 遍历 map, 读取 k, v
+	for k, v := range map1 {
+		fmt.Printf("k = %d - v = %f\n", k, v)
+	}
+
+	// 遍历 map, 只读 k
+	for k := range map1 {
+		fmt.Printf("k = %d\n", k)
+	}
+
+	// 遍历 map, 只读 v
+	for _, v := range map1 {
+		fmt.Printf("v = %f\n", v)
+	}
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 100))
+
+	// 遍历 channel
+	ch_length := 10
+	ch := make(chan int, ch_length)
+	for i := 0; i < ch_length; i++ {
+		ch <- i
+	}
+	close(ch)
+	for v := range ch {
+		fmt.Println(v)
+	}
+}

golang-learn/49-recursive/main.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+// 递归函数计算阶乘
+func factorial(n int) int {
+	// 基准条件
+	if n == 0 {
+		return 1
+	}
+	// 递归条件
+	fmt.Println(n)
+	return n * factorial(n-1)
+}
+
+func main() {
+	fmt.Println(factorial(5)) // 输出: 120
+}

golang-learn/50-type_conversion/main.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func main() {
+	var sum int = 17
+	var count int = 5
+	var mean float32
+
+	// int 转 float32
+	mean = float32(sum) / float32(count)
+	fmt.Printf("mean 的值为: %f\n", mean)
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 88))
+
+	// float32 转 int
+	var test_num = float32(7) / float32(3)
+	fmt.Printf("测试float32转int:\nfloat32(7) / float32(3) = %d\n", int(test_num))
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 88))
+
+	// string 转 int
+	var str string = "10"
+	// var num int
+
+	num, err := strconv.Atoi(str)
+	if err != nil {
+		fmt.Printf("转换变量 str 报错: %s\n", err)
+	} else {
+		fmt.Printf("转换了变量 str , 现在的值是: %d, 类型是: %T\n", num, num)
+	}
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 88))
+
+	// string 转 float
+	str = "3.14"
+	num_float, err := strconv.ParseFloat(str, 64)
+	if err != nil {
+		fmt.Println("转换错误:", err)
+	} else {
+		fmt.Printf("字符串 '%s' 转为浮点型为：%f\n", str, num_float)
+	}
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 88))
+
+	// float 转 string
+	num_int := 3.14
+	str = strconv.FormatFloat(num_int, 'f', 2, 64)
+	fmt.Printf("浮点数 %f 转为字符串为：'%s'\n", num_int, str)
+
+	fmt.Printf("\n%s\n\n", strings.Repeat("*", 88))
+
+	// 接口类型转换
+	// 接口类型转换有两种情况：类型断言和类型转换。
+	var i interface{} = "Hello, World"
+	str, ok := i.(string)
+	if ok {
+		fmt.Printf("'%s' is a string\n", str)
+	} else {
+		fmt.Println("conversion failed")
+	}
+}

golang-learn/51-interface2/main.go

@@ -0,0 +1,409 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+func main() {
+	fmt.Println("=== Go 接口、类型断言和类型转换演示 ===\n")
+
+	// 1. 接口基本演示
+	demoInterface()
+
+	// 2. 空接口演示
+	demoEmptyInterface()
+
+	// 3. 类型断言演示
+	demoTypeAssertion()
+
+	// 4. 类型转换演示
+	demoTypeConversion()
+
+	// 5. 综合应用示例
+	demoComprehensive()
+}
+
+// ================================
+// 1. 接口定义和实现
+// ================================
+
+// Writer 接口定义
+type Writer interface {
+	Write([]byte) (int, error)
+}
+
+// Reader 接口定义
+type Reader interface {
+	Read([]byte) (int, error)
+}
+
+// ReadWriter 组合接口
+type ReadWriter interface {
+	Reader
+	Writer
+}
+
+// File 结构体实现接口
+type File struct {
+	name string
+}
+
+// File 实现 Writer 接口
+func (f File) Write(data []byte) (int, error) {
+	fmt.Printf("Writing to %s: %s\n", f.name, string(data))
+	return len(data), nil
+}
+
+// File 实现 Reader 接口
+func (f File) Read(data []byte) (int, error) {
+	content := fmt.Sprintf("Content from %s", f.name)
+	copy(data, []byte(content))
+	fmt.Printf("Reading from %s\n", f.name)
+	return len(content), nil
+}
+
+func demoInterface() {
+	fmt.Println("1. 接口基本演示:")
+	fmt.Println("----------------")
+
+	var w Writer = File{"example.txt"}
+	w.Write([]byte("Hello World"))
+
+	var r Reader = File{"data.txt"}
+	r.Read(make([]byte, 50))
+
+	var rw ReadWriter = File{"readwrite.txt"}
+	rw.Write([]byte("Data to write"))
+	rw.Read(make([]byte, 50))
+
+	fmt.Println()
+}
+
+// ================================
+// 2. 空接口演示
+// ================================
+
+// printAnything 接受任何类型的空接口参数
+func printAnything(v interface{}) {
+	fmt.Printf("值: %v, 类型: %T\n", v, v)
+}
+
+func demoEmptyInterface() {
+	fmt.Println("2. 空接口演示:")
+	fmt.Println("----------------")
+
+	printAnything(42)             // int
+	printAnything("hello")        // string
+	printAnything([]int{1, 2, 3}) // slice
+	printAnything(3.14)           // float64
+	printAnything(true)           // bool
+
+	fmt.Println()
+}
+
+// ================================
+// 3. 类型断言演示
+// ================================
+
+// Animal 接口
+type Animal interface {
+	Speak() string
+}
+
+// Dog 实现 Animal 接口
+type Dog struct{ name string }
+
+func (d Dog) Speak() string {
+	return "Woof! My name is " + d.name
+}
+
+// Cat 实现 Animal 接口
+type Cat struct{ name string }
+
+func (c Cat) Speak() string {
+	return "Meow! My name is " + c.name
+}
+
+// checkType 使用类型断言检查接口类型
+func checkType(i interface{}) {
+	switch v := i.(type) {
+	case int:
+		fmt.Printf("整数: %d\n", v)
+	case string:
+		fmt.Printf("字符串: %s\n", v)
+	case bool:
+		fmt.Printf("布尔值: %t\n", v)
+	case Dog:
+		fmt.Printf("狗狗在说话: %s\n", v.Speak())
+	case Cat:
+		fmt.Printf("猫咪在说话: %s\n", v.Speak())
+	default:
+		fmt.Printf("未知类型: %T\n", v)
+	}
+}
+
+func demoTypeAssertion() {
+	fmt.Println("3. 类型断言演示:")
+	fmt.Println("----------------")
+
+	// 基本类型断言
+	var i interface{} = "hello world"
+
+	// 安全的方式：检查是否成功
+	if s, ok := i.(string); ok {
+		fmt.Printf("断言成功，是字符串: %s\n", s)
+	} else {
+		fmt.Println("不是字符串")
+	}
+
+	// 检查其他类型失败的情况
+	if n, ok := i.(int); ok {
+		fmt.Printf("是整数: %d\n", n)
+	} else {
+		fmt.Println("不是整数")
+	}
+
+	// 类型switch演示
+	fmt.Println("\n类型switch演示:")
+	checkType(42)
+	checkType("golang")
+	checkType(true)
+	checkType(Dog{"Buddy"})
+	checkType(Cat{"Kitty"})
+
+	// 接口类型断言
+	fmt.Println("\n接口类型断言:")
+	var a Animal = Dog{"Rex"}
+
+	if dog, ok := a.(Dog); ok {
+		fmt.Println("这是一只狗:", dog.Speak())
+	}
+
+	a = Cat{"Mimi"}
+	if cat, ok := a.(Cat); ok {
+		fmt.Println("这是一只猫:", cat.Speak())
+	}
+
+	fmt.Println()
+}
+
+// ================================
+// 4. 类型转换演示
+// ================================
+
+// 自定义温度类型
+type Celsius float64
+type Fahrenheit float64
+
+// 温度转换函数
+func CToF(c Celsius) Fahrenheit {
+	return Fahrenheit(c*9/5 + 32)
+}
+
+func FToC(f Fahrenheit) Celsius {
+	return Celsius((f - 32) * 5 / 9)
+}
+
+// 为Celsius实现String方法
+func (c Celsius) String() string {
+	return fmt.Sprintf("%.1f°C", c)
+}
+
+func (f Fahrenheit) String() string {
+	return fmt.Sprintf("%.1f°F", f)
+}
+
+func demoTypeConversion() {
+	fmt.Println("4. 类型转换演示:")
+	fmt.Println("----------------")
+
+	// 基本类型转换
+	var integer int = 42
+	var floatNum float64 = float64(integer)
+	var unsigned uint = uint(floatNum)
+
+	fmt.Printf("整数: %d, 浮点数: %.2f, 无符号整数: %d\n",
+		integer, floatNum, unsigned)
+
+	// 字符串和字节切片转换
+	text := "Hello, Go!"
+	bytes := []byte(text)
+	textAgain := string(bytes)
+
+	fmt.Printf("原字符串: %s\n", text)
+	fmt.Printf("字节切片: %v\n", bytes)
+	fmt.Printf("转换回字符串: %s\n", textAgain)
+
+	// 自定义类型转换
+	fmt.Println("\n自定义类型转换(温度):")
+	freezingC := Celsius(0)
+	freezingF := CToF(freezingC)
+	fmt.Printf("冰点: %s = %s\n", freezingC, freezingF)
+
+	boilingF := Fahrenheit(212)
+	boilingC := FToC(boilingF)
+	fmt.Printf("沸点: %s = %s\n", boilingF, boilingC)
+
+	// rune和字符串转换
+	chinese := "你好世界"
+	runes := []rune(chinese)
+	backToString := string(runes)
+	fmt.Printf("\n中文字符串: %s\n", chinese)
+	fmt.Printf("Rune数组: %v\n", runes)
+	fmt.Printf("转换回字符串: %s\n", backToString)
+
+	fmt.Println()
+}
+
+// ================================
+// 5. 综合应用示例
+// ================================
+
+// Processor 数据处理接口
+type Processor interface {
+	Process() interface{}
+	GetType() string
+}
+
+// StringProcessor 字符串处理器
+type StringProcessor struct {
+	data string
+}
+
+func (sp StringProcessor) Process() interface{} {
+	return strings.ToUpper(sp.data)
+}
+
+func (sp StringProcessor) GetType() string {
+	return "string"
+}
+
+// IntProcessor 整数处理器
+type IntProcessor struct {
+	data int
+}
+
+func (ip IntProcessor) Process() interface{} {
+	return ip.data * 2
+}
+
+func (ip IntProcessor) GetType() string {
+	return "int"
+}
+
+// processData 处理不同类型的数据
+func processData(processor Processor) {
+	fmt.Printf("处理 %s 类型数据: ", processor.GetType())
+
+	result := processor.Process()
+
+	// 使用类型断言处理不同类型的结果
+	switch v := result.(type) {
+	case string:
+		fmt.Printf("字符串结果: '%s'\n", v)
+	case int:
+		fmt.Printf("整数结果: %d\n", v)
+	default:
+		fmt.Printf("未知结果类型: %T\n", v)
+	}
+}
+
+// Config 配置接口
+type Config interface {
+	Validate() error
+	Display()
+}
+
+// DatabaseConfig 数据库配置
+type DatabaseConfig struct {
+	Host     string `json:"host"`
+	Port     int    `json:"port"`
+	Username string `json:"username"`
+}
+
+func (dc DatabaseConfig) Validate() error {
+	if dc.Host == "" {
+		return errors.New("主机名不能为空")
+	}
+	if dc.Port <= 0 || dc.Port > 65535 {
+		return errors.New("端口号必须在1-65535之间")
+	}
+	return nil
+}
+
+func (dc DatabaseConfig) Display() {
+	fmt.Printf("数据库配置: Host=%s, Port=%d, Username=%s\n",
+		dc.Host, dc.Port, dc.Username)
+}
+
+// loadConfig 模拟配置加载
+func loadConfig(configData map[string]interface{}) error {
+	fmt.Println("\n加载配置演示:")
+
+	if dbConfig, ok := configData["database"].(map[string]interface{}); ok {
+		// 类型断言确保类型安全
+		host, hostOk := dbConfig["host"].(string)
+		port, portOk := dbConfig["port"].(float64) // JSON数字默认是float64
+		username, userOk := dbConfig["username"].(string)
+
+		if !hostOk || !portOk || !userOk {
+			return errors.New("数据库配置格式错误")
+		}
+
+		config := DatabaseConfig{
+			Host:     host,
+			Port:     int(port), // 类型转换
+			Username: username,
+		}
+
+		if err := config.Validate(); err != nil {
+			return fmt.Errorf("数据库配置验证失败: %v", err)
+		}
+
+		config.Display()
+		fmt.Println("✅ 数据库配置验证通过")
+	}
+
+	return nil
+}
+
+func demoComprehensive() {
+	fmt.Println("5. 综合应用示例:")
+	fmt.Println("=================")
+
+	// 数据处理管道演示
+	fmt.Println("数据处理管道:")
+	processData(StringProcessor{"hello golang"})
+	processData(IntProcessor{21})
+
+	// 配置加载演示
+	configData := map[string]interface{}{
+		"database": map[string]interface{}{
+			"host":     "localhost",
+			"port":     3306.0, // 注意JSON中的数字是float64
+			"username": "admin",
+		},
+	}
+
+	if err := loadConfig(configData); err != nil {
+		fmt.Printf("配置加载错误: %v\n", err)
+	}
+
+	// 错误配置演示
+	fmt.Println("\n错误配置演示:")
+	badConfig := map[string]interface{}{
+		"database": map[string]interface{}{
+			"host":     "",      // 空主机名
+			"port":     70000.0, // 无效端口
+			"username": "admin",
+		},
+	}
+
+	if err := loadConfig(badConfig); err != nil {
+		fmt.Printf("❌ 配置错误: %v\n", err)
+	}
+
+	fmt.Println("\n=== 演示结束 ===")
+}

golang-learn/Note.md

@@ -0,0 +1,421 @@
+### 环境安装
+```text
+https://go.dev/dl/
+https://golang.google.cn/dl/
+```
+
+### Hello, World!
+```go
+package main
+
+import "fmt"
+
+func main() {
+   fmt.Println("Hello, World!")
+}
+```
+
+### 基础
+#### 变量和数据类型
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // 字符串
+    name := "张三"
+    // 整数
+    age := 25
+    // 浮点数
+    height := 1.75
+    // 布尔值
+    isStudent := true
+    // 数组
+    hobbies := [3]string{"读书", "编程", "音乐"}
+    // 切片（动态数组）
+    scores := []int{85, 92, 78}
+
+    fmt.Printf("姓名: %s\n", name)
+    fmt.Printf("年龄: %d 岁\n", age)
+    fmt.Printf("身高: %.2f 米\n", height)
+    fmt.Printf("是学生: %t\n", isStudent)
+    fmt.Printf("爱好: %v\n", hobbies)
+    fmt.Printf("成绩: %v\n", scores)
+}
+```
+#### 条件判断
+```go
+package main
+
+import "fmt"
+
+func getGrade(score int) string {
+    if score >= 90 {
+        return "优秀"
+    } else if score >= 80 {
+        return "良好"
+    } else if score >= 60 {
+        return "及格"
+    } else {
+        return "不及格"
+    }
+}
+
+func main() {
+    fmt.Println(getGrade(95)) // 输出: 优秀
+    fmt.Println(getGrade(75)) // 输出: 及格
+    
+    // switch 语句
+    grade := "B"
+    switch grade {
+    case "A":
+        fmt.Println("优秀")
+    case "B":
+        fmt.Println("良好")
+    case "C":
+        fmt.Println("及格")
+    default:
+        fmt.Println("不及格")
+    }
+}
+```
+#### 循环
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // for循环 - 遍历切片
+    fruits := []string{"苹果", "香蕉", "橙子", "葡萄"}
+    fmt.Println("我喜欢的水果:")
+    for i, fruit := range fruits {
+        fmt.Printf("%d. %s\n", i+1, fruit)
+    }
+
+    // 传统的for循环
+    fmt.Println("\n计数到5:")
+    for i := 1; i <= 5; i++ {
+        fmt.Println(i)
+    }
+
+    // while循环（用for实现）
+    count := 1
+    fmt.Println("\n用while风格计数:")
+    for count <= 3 {
+        fmt.Println(count)
+        count++
+    }
+}
+```
+#### 切片和Map
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // 切片操作
+    numbers := []int{1, 2, 3, 4, 5}
+
+    // 添加元素
+    numbers = append(numbers, 6, 7)
+    fmt.Println("添加后:", numbers)
+
+    // 切片切片
+    slice1 := numbers[1:4] // [2,3,4]
+    fmt.Println("切片:", slice1)
+
+    // Map（字典）
+    studentScores := map[string]int{
+        "张三": 85,
+        "李四": 92,
+        "王五": 78,
+    }
+
+    // 添加元素
+    studentScores["赵六"] = 88
+
+    // 遍历map
+    for name, score := range studentScores {
+        fmt.Printf("%s: %d分\n", name, score)
+    }
+
+    // 检查key是否存在
+    if score, exists := studentScores["张三"]; exists {
+        fmt.Printf("张三的分数是: %d\n", score)
+    }
+}
+```
+#### 错误处理 
+```go
+package main
+
+import (
+    "errors"
+    "fmt"
+)
+
+// 自定义错误
+func divide(a, b float64) (float64, error) {
+    if b == 0 {
+        return 0, errors.New("除数不能为零")
+    }
+    return a / b, nil
+}
+
+func main() {
+    // 正常情况
+    result, err := divide(10, 2)
+    if err != nil {
+        fmt.Println("错误:", err)
+    } else {
+        fmt.Printf("结果: %.2f\n", result)
+    }
+
+    // 错误情况
+    result, err = divide(10, 0)
+    if err != nil {
+        fmt.Println("错误:", err)
+    } else {
+        fmt.Printf("结果: %.2f\n", result)
+    }
+
+    //  defer 延迟执行（类似finally）
+    defer fmt.Println("程序执行完成")
+    fmt.Println("正在计算...")
+}
+```
+
+
+### 函数
+#### 1.普通函数 (Function)
+```go
+// 普通函数
+func 函数名(参数) 返回值 {
+    // 函数体
+}
+```
+#### 2.方法 (Method)
+```go
+// 方法 = 函数 + 接收者
+func (接收者) 方法名(参数) 返回值 {
+    // 方法体
+}
+```
+#### 3.接口方法 (Interface Method)
+```go
+// 接口方法（在接口中定义）
+type 接口名 interface {
+    方法名(参数) 返回值
+    // 只有方法签名，没有实现
+}
+```
+#### 4.自定义函数类型 (Custom Function Type)
+```go
+// 自定义函数类型
+type 类型名 func(参数) 返回值
+
+// 为自定义函数类型添加方法
+func (f 类型名) 方法名(参数) 返回值 {
+    // 方法体
+}
+```
+#### 5.泛型函数 (Generic Function)
+```go
+// 泛型函数
+func 函数名[T 约束](参数 T) T {
+    // 函数体
+}
+
+// 泛型方法
+func (接收者) 方法名[T 约束](参数 T) T {
+    // 方法体
+}
+
+// 泛型接口
+type 接口名[T 约束] interface {
+    方法名(参数 T) T
+}
+```
+#### 6.泛型自定义函数类型
+```go
+// 泛型自定义函数类型
+type 类型名[T 约束] func(参数 T) T
+
+// 为泛型自定义函数类型添加泛型方法
+func (f 类型名[T]) 方法名[U 约束](参数 U) U {
+    // 方法体
+}
+```
+#### 层次关系
+```text
+普通函数 → 基础构建块
+    ↓
+方法 → 普通函数 + 接收者（绑定到类型）
+    ↓
+接口方法 → 方法的抽象契约（只有签名）
+    ↓
+自定义函数类型 → 函数作为一等公民的类型化
+    ↓
+泛型函数/方法 → 类型参数化的通用实现
+    ↓  
+泛型接口 → 支持类型参数的抽象契约
+```
+
+### 作用域
+#### 块作用域
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // 作用域起点：变量 x 在整个 main 函数块内可见
+    x := 10
+    fmt.Println(x) // 输出 10
+
+    {
+        // 这是一个内部块
+        y := 20 // 变量 y 只在这个内部块中可见
+        fmt.Println(x, y) // 输出 10 20 (x 可见，y 可见)
+    }
+
+    // fmt.Println(y) // 编译错误！undefined: y (y 的作用域结束了)
+
+    if x > 5 {
+        // if 语句隐式块开始
+        z := 30 // z 的作用域仅限于这个 if 块
+        fmt.Println(x, z) // 输出 10 30
+    }
+
+    // fmt.Println(z) // 编译错误！undefined: z (z 的作用域结束了)
+
+    for i := 0; i < 3; i++ { // i 的作用域是整个 for 语句块（包括条件判断和循环体）
+        fmt.Println(i)
+    }
+    // fmt.Println(i) // 编译错误！undefined: i (i 的作用域结束了)
+}
+```
+#### 词法作用域
+```go
+package main
+
+import "fmt"
+
+func outer() func() int {
+    count := 0 // count 的作用域是 outer 函数
+    // 内部函数 inner 是一个闭包，它“捕获”了变量 count
+    inner := func() int {
+        count++ // inner 可以访问其外部作用域（即 outer 函数）的变量 count
+        return count
+    }
+    return inner // 返回这个闭包函数
+}
+
+func main() {
+    counter := outer()
+    fmt.Println(counter()) // 输出 1
+    fmt.Println(counter()) // 输出 2 (count 的状态被保留了)
+
+    anotherCounter := outer() // 创建一个新的闭包，拥有自己独立的 count 变量
+    fmt.Println(anotherCounter()) // 输出 1
+}
+```
+#### 包作用域
+```go
+package main
+
+import "fmt"
+
+// 包级作用域（包内所有文件可见）
+var globalVar = "I am global" // 小写开头，仅包内可见
+const GlobalConst = "I am public" // 大写开头，导出，其他包可访问
+
+func main() {
+    fmt.Println(globalVar)    // 可见
+    fmt.Println(GlobalConst)  // 可见
+    someFunction()            // 可见
+}
+```
+
+```go
+package main
+
+import "fmt"
+
+// 这个函数在整个包内都可见
+func someFunction() {
+    fmt.Println("Accessing from another file:", globalVar) // globalVar 在此文件可见
+}
+
+// 这个函数是私有的，仅在包内可用
+func privateFunc() {
+    // ...
+}
+```
+
+```go
+package otherpackage
+
+import "mypackage"
+
+func someFunc() {
+    // fmt.Println(mypackage.globalVar)   // 错误！globalVar 是小写，不可见
+    fmt.Println(mypackage.GlobalConst) // 正确！GlobalConst 是大写，已导出
+    // mypackage.privateFunc()           // 错误！privateFunc 是小写，不可见
+}
+```
+
+### 结构体和方法
+```go
+package main
+
+import "fmt"
+
+// 定义结构体
+type Student struct {
+    Name     string
+    ID       string
+    Grades   []int
+}
+
+// 为结构体定义方法
+func (s *Student) AddGrade(grade int) {
+    s.Grades = append(s.Grades, grade)
+}
+
+func (s Student) GetAverage() float64 {
+    if len(s.Grades) == 0 {
+        return 0
+    }
+    sum := 0
+    for _, grade := range s.Grades {
+        sum += grade
+    }
+    return float64(sum) / float64(len(s.Grades))
+}
+
+func (s Student) DisplayInfo() {
+    fmt.Printf("学生姓名: %s\n", s.Name)
+    fmt.Printf("学号: %s\n", s.ID)
+    fmt.Printf("成绩: %v\n", s.Grades)
+    fmt.Printf("平均分: %.2f\n", s.GetAverage())
+}
+
+func main() {
+    // 创建结构体实例
+    student1 := Student{
+        Name: "小明",
+        ID:   "2024001",
+    }
+
+    student1.AddGrade(85)
+    student1.AddGrade(92)
+    student1.AddGrade(78)
+
+    student1.DisplayInfo()
+}
+```
+