一.匿名函数
go语言中，匿名函数和java中内部类有相似之处，java的内部类是只调用一次。
1.匿名函数的声明
func(参数列表) 返回值列表 {
函数体...
}
2.匿名函数的调用：一种是赋值给变量，进行调用；另外一种是 匿名变量后面加（args 参数列表）直接调用
package main
import "fmt"
func main() {
// 方式1
// 匿名函数的声明 赋值给一个变量
c := func(a, b int) (max, min int) {
if a > b {
max, min = a, b
} else {
max, min = b, a
}
return
}
c() // 匿名函数的调用
// 方式2
func(age int) {
fmt.Printf("age=v%\n", age)
}(2) //直接调用
}二.闭包的捕获外部环境变量
闭包，就是函数与函数特定环境的组合，闭包使用了本函数之外定义的变量。会超出闭包内的作用域。但是在函数的不同的执行的过程中，会产生不同的闭包，这些闭包之间的变量不是共享，因为函数的每次执行都会重新生成新的局部变量，使得闭包每次绑定的变量不同
package main
import "fmt"
func main() {
a := 12
b := "aaa"
func() {
//闭包以引用方式捕获外部的变量
a = 34
b = "bbb"
fmt.Printf("内部：a=%v,b=%v\n", a, b) // a=34 b=bbb
}() //()代表直接进行调用
fmt.Printf("外部：a=%v,b=%v\n", a, b) // a=34 b=bbb
}
三.闭包的特点
它不关心这些捕获了的变量和常量是否已经超出了作用域
因此只要闭包还在使用，这些变量就还会存在
当X被调用的时候，x才会分配空间，才初始化为0
package main
import "fmt"
// 函数的返回值就是一个匿名函数，返回一个函数类型
func test02() func() int {
// 没有初始化，初始值为0
var x int
return func() int {
x++
return x * x
}
}
func main() {
//返回值为一个匿名函数，返回一个函数类型，通过f来调用返回的匿名函数，f来调用闭包函数
// 它不关心这些捕获了的变量和常量是否已经超出了作用域
//因此只要闭包还在使用，这些变量就还会存在
f := test02()
fmt.Println(f())
fmt.Println(f())
}
/////////////////////////////////////////////////////
func test01() int {
//当X被调用的时候，x才会分配空间，才初始化为0
var x int //没有初始化，默认值为0
x++
return x * x //函数调用完毕，x自动释放
}
func main01() {
a := test01()
fmt.Printf("a=%d\n", a)
fmt.Println(test01())
}