1、Go语言基础中的基础

摘要：马士兵教育的Go语言基础的视频笔记。

第一章：走进Golang

1.1、Go的SDK介绍

1.2、Go的项目基本目录结构

1.3、HelloWorld

1.4、编译

1.5、执行

1.6、一步到位

1.7、执行流程分析

1.8、语法注意事项

（1）源文件以"go"为扩展名。
（2）程序的执行入口是main()函数。
（3）严格区分大小写。
（4）方法由一条条语句构成，每个语句后不需要分号(Go语言会在每行后自动加分号)，这也体现出Golang的简洁性。
（5）Go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否则报错
（6）定义的变量或者import的包如果没有使用到，代码不能编译通过。
（7）大括号都是成对出现的，缺一不可。

1.9、语法注意事项

1.9、语法注意事项

1.10、语法注意事项

第二章：变量与数据类型

2.1、变量

2.2、代码练习

package main
import "fmt"
func main(){
        //1.变量的声明
        var age int
        //2.变量的赋值
        age = 18
        //3.变量的使用
        fmt.Println("age = ",age);
        //声明和赋值可以合成一句：
        var age2 int = 19
        fmt.Println("age2 = ",age2);
        // var age int = 20;
        // fmt.Println("age = ",age);
        /*变量的重复定义会报错：
                # command-line-arguments
                .\main.go:16:6: age redeclared in this block
                                previous declaration at .\main.go:6:6
        */
        //不可以在赋值的时候给与不匹配的类型
        var num int = 12.56
        fmt.Println("num = ",num);
}

2.3、变量的4种声明方式

package main
import "fmt"
//全局变量：定义在函数外的变量
var n7 = 100
var n8 = 9.7
//设计者认为上面的全局变量的写法太麻烦了，可以一次性声明：
var (
        n9 = 500
        n10 = "netty"
)
func main(){
        //定义在{}中的变量叫：局部变量
        //第一种：变量的使用方式：指定变量的类型，并且赋值，
        var num int = 18
        fmt.Println(num)
        //第二种：指定变量的类型，但是不赋值，使用默认值 
        var num2 int
        fmt.Println(num2)
        //第三种：如果没有写变量的类型，那么根据=后面的值进行判定变量的类型 （自动类型推断）
        var num3 = "tom"
        fmt.Println(num3)
        //第四种：省略var，注意 := 不能写为 =   
        sex := "男"
        fmt.Println(sex)
        fmt.Println("------------------------------------------------------------------")
        //声明多个变量：
        var n1,n2,n3 int
        fmt.Println(n1)
        fmt.Println(n2)
        fmt.Println(n3)
        var n4,name,n5 = 10,"jack",7.8
        fmt.Println(n4)
        fmt.Println(name)
        fmt.Println(n5)
        n6,height := 6.9,100.6
        fmt.Println(n6)
        fmt.Println(height)
        fmt.Println(n7)
        fmt.Println(n8)
        fmt.Println(n9)
        fmt.Println(n10)
}

2.3、数据类型介绍

2.3.1、进制介绍

【1】进制的介绍：
十进制整数，如：99, -500, 0
八进制整数，要求以 0 开头，如：015
十六进制数，要求 0x 或 0X 开头，如：0x15
二进制：要求0b或者0B开头，如：0b11

2.3.2、数据类型

package main
import "fmt"
func main(){
        //定义浮点类型的数据：
        var num1 float32 = 3.14
        fmt.Println(num1)
        //可以表示正浮点数，也可以表示负的浮点数
        var num2 float32 = -3.14
        fmt.Println(num2)
        //浮点数可以用十进制表示形式，也可以用科学计数法表示形式  E 大写小写都可以的
        var num3 float32 = 314E-2 
        fmt.Println(num3)
        var num4 float32 = 314E+2
        fmt.Println(num4)
        var num5 float32 = 314e+2
        fmt.Println(num5)
        var num6 float64 = 314e+2
        fmt.Println(num6)
        //浮点数可能会有精度的损失，所以通常情况下，建议你使用：float64 
        var num7 float32 = 256.000000916
        fmt.Println(num7)
        var num8 float64 = 256.000000916
        fmt.Println(num8)
        //golang中默认的浮点类型为：float64 
        var num9 = 3.17
        fmt.Printf("num9对应的默认的类型为：%T",num9)
}

【4】查看UTF-8编码表：
http://www.mytju.com/classcode/tools/encode_utf8.asp

package main
import "fmt"
func main(){
        //定义字符类型的数据：
        var c1 byte = 'a'
        fmt.Println(c1)//97
        var c2 byte = '6'
        fmt.Println(c2)//54
        var c3 byte = '('
        fmt.Println(c3 + 20)//40
        //字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
        //字母，数字，标点等字符，底层是按照ASCII进行存储。
        var c4 int = '中'
        fmt.Println(c4)
        //汉字字符，底层对应的是Unicode码值
        //对应的码值为20013，byte类型溢出，能存储的范围：可以用int
        //总结：Golang的字符对应的使用的是UTF-8编码（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）
        var c5 byte = 'A'
        //想显示对应的字符，必须采用格式化输出
        fmt.Printf("c5对应的具体的字符为：%c",c5)
}

package main
import "fmt"
func main(){
        //练习转义字符：
        //\n  换行
        fmt.Println("aaa\nbbb")
        //\b 退格
        fmt.Println("aaa\bbbb")
        //\r 光标回到本行的开头，后续输入就会替换原有的字符
        fmt.Println("aaaaa\rbbb")
        //\t 制表符
        fmt.Println("aaaaaaaaaaaaa")
        fmt.Println("aaaaa\tbbbbb")
        fmt.Println("aaaaaaaa\tbbbbb")
        //\"
        fmt.Println("\"Golang\"")
}

package main
import "fmt"
func main(){
        //测试布尔类型的数值：
        var flag01 bool = true
        fmt.Println(flag01)
        var flag02 bool = false
        fmt.Println(flag02)
        var flag03 bool = 5 < 9
        fmt.Println(flag03)
}

package main
import "fmt"
func main(){
        //1.定义一个字符串：
        var s1 string = "你好全面拥抱Golang"
        fmt.Println(s1)
        //2.字符串是不可变的：指的是字符串一旦定义好，其中的字符的值不能改变
        var s2 string = "abc"
        //s2 = "def"
        //s2[0] = 't'
        fmt.Println(s2)
        //3.字符串的表示形式：
        //（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
        //var s3 string = "asdfasdfasdf"
        //（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
        var s4 string = `
        package main
        import "fmt"
        
        func main(){
                //测试布尔类型的数值：
                var flag01 bool = true
                fmt.Println(flag01)
        
                var flag02 bool = false
                fmt.Println(flag02)
        
                var flag03 bool = 5 < 9
                fmt.Println(flag03)
        }
        `
        fmt.Println(s4)
        //4.字符串的拼接效果：
        var s5 string = "abc" + "def"
        s5 += "hijk"
        fmt.Println(s5)
        //当一个字符串过长的时候：注意：+保留在上一行的最后
        var s6 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" +
         "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+
          "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" +
           "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + 
           "abc" + "def"+ "abc" + "def"
        fmt.Println(s6)
}

package main
import "fmt"
func main(){
        //进行类型转换：
        var n1 int = 100
        //var n2 float32 = n1  在这里自动转换不好使，比如显式转换
        fmt.Println(n1)
        //fmt.Println(n2)
        var n2 float32 = float32(n1)
        fmt.Println(n2)
        //注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型
        fmt.Printf("%T",n1)  //int
        fmt.Println()
        //将int64转为int8的时候，编译不会出错的，但是会数据的溢出
        var n3 int64 = 888888
        var n4 int8 = int8(n3)
        fmt.Println(n4)//56
        var n5 int32 = 12
        var n6 int64 = int64(n5) + 30  //一定要匹配=左右的数据类型
        fmt.Println(n5)
        fmt.Println(n6)
        var n7 int64 = 12
        var n8 int8 = int8(n7) + 127  //编译通过，但是结果可能会溢出
        //var n9 int8 = int8(n7) + 128 //编译不会通过
        fmt.Println(n8)
        //fmt.Println(n9)
}

package main
import "fmt"
func main(){
        var n1 int = 19
        var n2 float32 = 4.78
        var n3 bool = false
        var n4 byte = 'a'
        var s1 string = fmt.Sprintf("%d",n1)
        fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
        var s2 string = fmt.Sprintf("%f",n2)
        fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
        var s3 string = fmt.Sprintf("%t",n3)
        fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
        var s4 string = fmt.Sprintf("%c",n4)
        fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)
}

package main
import(
        "fmt"
        "strconv"
)
func main(){
        var n1 int = 18
        var s1 string = strconv.FormatInt(int64(n1),10)  //参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
        fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
        var n2 float64 = 4.29
        var s2 string = strconv.FormatFloat(n2,'f',9,64)
        //第二个参数：'f'（-ddd.dddd）  第三个参数：9 保留小数点后面9位  第四个参数：表示这个小数是float64类型
        fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
        var n3 bool = true
        var s3 string = strconv.FormatBool(n3)
        fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
}

package main
import(
        "fmt"
        "strconv"
)
func main(){
        //string-->bool
        var s1 string = "true"
        var b bool
        //ParseBool这个函数的返回值有两个：(value bool, err error)
        //value就是我们得到的布尔类型的数据，err出现的错误
        //我们只关注得到的布尔类型的数据，err可以用_直接忽略
        b , _ = strconv.ParseBool(s1)
        fmt.Printf("b的类型是：%T,b=%v \n",b,b)
        //string---》int64
        var s2 string = "19"
        var num1 int64
        num1,_ = strconv.ParseInt(s2,10,64)
        fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
        //string-->float32/float64
        var s3 string = "3.14"
        var f1 float64
        f1,_ = strconv.ParseFloat(s3,64)
        fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
        //注意：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出
        var s4 string = "golang"
        var b1 bool
        b1 , _ = strconv.ParseBool(s4)
        fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)
        var s5 string = "golang"
        var num2 int64
        num2,_ = strconv.ParseInt(s5,10,64)
        fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
}

package main
import(
        "fmt"
)
func main(){
        var age int = 18
        //&符号+变量 就可以获取这个变量内存的地址
        fmt.Println(&age) //0xc0000a2058
        //定义一个指针变量：
        //var代表要声明一个变量
        //ptr 指针变量的名字
        //ptr对应的类型是：*int 是一个指针类型 （可以理解为 指向int类型的指针）
        //&age就是一个地址，是ptr变量的具体的值
        var ptr *int = &age
        fmt.Println(ptr)
        fmt.Println("ptr本身这个存储空间的地址为：",&ptr)
        //想获取ptr这个指针或者这个地址指向的那个数据：
        fmt.Printf("ptr指向的数值为：%v",*ptr) //ptr指向的数值为：18
}

2.4、标识符的使用

（关于模块的导入，这里的方式比较老了，去学习go module即可）

2.4、关键字

第三章：运算符

3.1、算术运算符

package main
import "fmt"
func main(){
        //+加号：
        //1.正数 2.相加操作  3.字符串拼接
        var n1 int = +10
        fmt.Println(n1)
        var n2 int = 4 + 7
        fmt.Println(n2)
        var s1 string = "abc" + "def"
        fmt.Println(s1)
        // /除号：
        fmt.Println(10/3) //两个int类型数据运算，结果一定为整数类型
        fmt.Println(10.0/3)//浮点类型参与运算，结果为浮点类型
        // % 取模  等价公式： a%b=a-a/b*b
        fmt.Println(10%3) // 10%3= 10-10/3*3 = 1
        fmt.Println(-10%3)
        fmt.Println(10%-3)
        fmt.Println(-10%-3)
        //++自增操作：
        var a int = 10
        a++
        fmt.Println(a)
        a--
        fmt.Println(a)
        //++ 自增 加1操作，--自减，减1操作
        //go语言里，++，--操作非常简单，只能单独使用，不能参与到运算中去
        //go语言里，++，--只能在变量的后面，不能写在变量的前面 --a  ++a  错误写法
}

3.2、赋值运算符

3.3、关系运算符

3.4、逻辑运算符

package main
import "fmt"
func main(){
        //与逻辑：&& :两个数值/表达式只要有一侧是false，结果一定为false
        //也叫短路与：只要第一个数值/表达式的结果是false，那么后面的表达式等就不用运算了，
        // 直接结果就是false  -->提高运算效率
        fmt.Println(true&&true)
        fmt.Println(true&&false)
        fmt.Println(false&&true)
        fmt.Println(false&&false)
        //或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true
        //也叫短路或：只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了,,
        //直接结果就是true -->提高运算效率
        fmt.Println(true||true)
        fmt.Println(true||false)
        fmt.Println(false||true)
        fmt.Println(false||false)
        //非逻辑：取相反的结果：
        fmt.Println(!true)
        fmt.Println(!false)
}

3.5、其他运算符

3.6、位运算符的优先级别

3.7、获取用户的终端输入

package main
import "fmt"
func main(){
        //实现功能：键盘录入学生的年龄，姓名，成绩，是否是VIP
        //方式1：Scanln
        var age int
        // fmt.Println("请录入学生的年龄：")
        //传入age的地址的目的：在Scanln函数中，对地址中的值进行改变的时候，实际外面的age被影响了
        //fmt.Scanln(&age)//录入数据的时候，类型一定要匹配，因为底层会自动判定类型的
        var name string
        // fmt.Println("请录入学生的姓名：")
        // fmt.Scanln(&name)
        var score float32
        // fmt.Println("请录入学生的成绩：")
        // fmt.Scanln(&score)
        var isVIP bool
        // fmt.Println("请录入学生是否为VIP：")
        // fmt.Scanln(&isVIP)
        //将上述数据在控制台打印输出：
        //fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v",age,name,score,isVIP)
       
        //方式2：Scanf
        fmt.Println("请录入学生的年龄，姓名，成绩，是否是VIP，使用空格进行分隔")
        fmt.Scanf("%d %s %f %t",&age,&name,&score,&isVIP)
        //将上述数据在控制台打印输出：
        fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v",age,name,score,isVIP)
}

第四章：流程控制

4.1、分支结构

package main
import "fmt"
func main(){
        //实现功能：如果口罩的库存小于30个，提示：库存不足：
        //var count int = 100
        //单分支：
        // if count < 30 {
        // 	fmt.Println("对不起，口罩存量不足")
        // }
        //if后面表达式，返回结果一定是true或者false，
        //如果返回结果为true的话，那么{}中的代码就会执行
        //如果返回结果为false的话，那么{}中的代码就不会执行
        //if后面一定要有空格，和条件表达式分隔开来
        //{}一定不能省略
        //条件表达式左右的()是建议省略的
        //在golang里，if后面可以并列的加入变量的定义：
        if count := 20;count < 30 {
                fmt.Println("对不起，口罩存量不足")
        }
}

package main
import "fmt"
func main(){
        //实现功能：如果口罩的库存小于30个，提示：库存不足,否则提示：库存充足
        //定义口罩的数量：
        var count int = 70
        if count < 30 { //这个条件表达式返回的是true的话，后面{}执行了
                fmt.Println("库存不足")
        } else {//count >= 30
                fmt.Println("库存充足")
        }
        //双分支一定会二选一走其中一个分支。
        
}

package main
import "fmt"
func main(){
        //实现功能：根据给出的学生分数，判断学生的等级：
        // >=90  -----A
        // >=80  -----B
        // >=70  -----C
        // >=60  -----D
        // <60   -----E
        //方式1：利用if单分支实现：
        //定义一个学生的成绩：
        var score int = 18
        //对学生的成绩进行判定：
        // if score >= 90 {
        // 	fmt.Println("您的成绩为A级别")
        // }
        // if score >= 80 && score < 90 {
        // 	fmt.Println("您的成绩为B级别")
        // }
        // if score >= 70 && score < 80 {
        // 	fmt.Println("您的成绩为C级别")
        // }
        // if score >= 60 && score < 70 {
        // 	fmt.Println("您的成绩为D级别")
        // }
        // if score < 60 {
        // 	fmt.Println("您的成绩为E级别")
        // }
        //上面方式1利用多个单分支拼凑出多个选择，多个选择是并列的，依次从上而下顺序执行，即使走了第一个分支，那么其它分支也是需要判断
        
        //方式2：多分支：优点：如果已经走了一个分支了，那么下面的分支就不会再去判断执行了
        // if score >= 90 {
        // 	fmt.Println("您的成绩为A级别")
        // } else if score >= 80 {//else隐藏：score < 90
        // 	fmt.Println("您的成绩为B级别")
        // } else if score >= 70 {//score < 80
        // 	fmt.Println("您的成绩为C级别")
        // } else if score >= 60 {//score < 70
        // 	fmt.Println("您的成绩为D级别")
        // } else {//score < 60
        // 	fmt.Println("您的成绩为E级别")
        // } //建议你保证else的存在，只有有了else才会真正 起到多选一 的效果
        if score > 10 {
                fmt.Println("aaa")
        } else if score > 6{
                fmt.Println("bbb")
        }
}

4.2、switch

package main
import "fmt"
func main(){
        //实现功能：根据给出的学生分数，判断学生的等级：
        // >=90  -----A
        // >=80  -----B
        // >=70  -----C
        // >=60  -----D
        // <60   -----E
        //给出一个学生分数：
        var score int = 187
        //根据分数判断等级：
        //switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码。
        //default是用来“兜底”的一个分支，其它case分支都不走的情况下就会走default分支
        //default分支可以放在任意位置上，不一定非要放在最后。
        switch score/10 {
                case 10 :
                        fmt.Println("您的等级为A级")
                case 9 :
                        fmt.Println("您的等级为A级")
                case 8 :
                        fmt.Println("您的等级为B级")
                case 7 :
                        fmt.Println("您的等级为C级")
                case 6 :
                        fmt.Println("您的等级为D级")
                case 5 :
                        fmt.Println("您的等级为E级")
                case 4 :
                        fmt.Println("您的等级为E级")
                case 3 :
                        fmt.Println("您的等级为E级")
                case 2 :
                        fmt.Println("您的等级为E级")
                case 1 :
                        fmt.Println("您的等级为E级")
                case 0 :
                        fmt.Println("您的等级为E级")
                default:
                        fmt.Println("您的成绩有误")
        }
        
}

4.3、循环结构

package main
import "fmt"
func main(){
        //实现一个功能：求和： 1+2+3+4+5：
        //求和：
        //利用for循环来解决问题：
        var sum int = 0
        for i := 1 ; i <= 5 ; i++ {
                sum += i
        }
        
        //输出结果：
        fmt.Println(sum)
        // for循环的语法格式：
        // for 初始表达式; 布尔表达式（条件判断）; 迭代因子 {
        // 	循环体;--》反复重复执行的内容
        // }
        // 注意：for的初始表达式 不能用var定义变量的形式，要用:=
        // 注意：for循环实际就是让程序员写代码的效率高了，
        // 但是底层该怎么执行还是怎么执行的，底层效率没有提高，只是程序员写代码简洁了而已
}

package main
import "fmt"
func main(){
        //定义一个字符串：
        var str string = "hello golang你好"
        //方式1：普通for循环：按照字节进行遍历输出的 （暂时先不使用中文）
        // for i := 0;i < len(str);i++ {//i:理解为字符串的下标
        // 	fmt.Printf("%c \n",str[i])
        // }
        //方式2：for range
        for i , value := range str {
                fmt.Printf("索引为：%d,具体的值为：%c \n",i,value)
        }
        //对str进行遍历，遍历的每个结果的索引值被i接收，每个结果的具体数值被value接收
        //遍历对字符进行遍历的
}

4.3、循环结构的关键字

第五章：函数

5.1、函数的引入

package main
import "fmt"
// func   函数名（形参列表)（返回值类型列表）{
// 	执行语句..
// 	return + 返回值列表
// }
//自定义函数：功能：两个数相加：
func cal (num1 int,num2 int) (int) { //如果返回值类型就一个的话，那么()是可以省略不写的
        var sum int = 0
        sum += num1
        sum += num2
        return sum
}
func main(){
        //功能：10 + 20
        //调用函数：
        sum := cal(10,20)
        fmt.Println(sum)
        // var num1 int = 10
        // var num2 int = 20
        //求和：
        // var sum int = 0
        // sum += num1
        // sum += num2
        // fmt.Println(sum)
        //功能：30 + 50
        var num3 int = 30
        var num4 int = 50
        //调用函数：
        sum1 := cal(num3,num4)
        fmt.Println(sum1)
        //求和：
        // var sum1 int = 0
        // sum1 += num3
        // sum1 += num4
        // fmt.Println(sum1)
}

package main
import "fmt"
//定义一个函数：
func test(num int){
        fmt.Println(num)
}
func main(){
        //函数也是一种数据类型，可以赋值给一个变量	
        a := test//变量就是一个函数类型的变量
        fmt.Printf("a的类型是：%T,test函数的类型是：%T \n",a,test)//a的类型是：func(int),test函数的类型是：func(int)
        //通过该变量可以对函数调用
        a(10) //等价于  test(10)
}

package main
import "fmt"
//定义一个函数：
func test(num int){
        fmt.Println(num)
}
//定义一个函数，把另一个函数作为形参：
func test02 (num1 int ,num2 float32, testFunc func(int)){
        fmt.Println("-----test02")
}
func main(){
        //函数也是一种数据类型，可以赋值给一个变量	
        a := test//变量就是一个函数类型的变量
        fmt.Printf("a的类型是：%T,test函数的类型是：%T \n",a,test)//a的类型是：func(int),test函数的类型是：func(int)
        //通过该变量可以对函数调用
        a(10) //等价于  test(10)
        //调用test02函数：
        test02(10,3.19,test)
        test02(10,3.19,a)
}

5.2、包的引入

5.4、init函数

5.5、匿名函数

package main
import "fmt"
var Func01 = func (num1 int,num2 int) int{
        return num1 * num2
}
func main(){
        //定义匿名函数：定义的同时调用
        result := func (num1 int,num2 int) int{
                return num1 + num2
        }(10,20)
        fmt.Println(result)
        //将匿名函数赋给一个变量，这个变量实际就是函数类型的变量
        //sub等价于匿名函数
        sub := func (num1 int,num2 int) int{
                return num1 - num2
        }
        //直接调用sub就是调用这个匿名函数了
        result01 := sub(30,70)
        fmt.Println(result01)
        result02 := sub(30,70)
        fmt.Println(result02)
        result03 := Func01(3,4)
        fmt.Println(result03)
}

5.6、闭包

package main
import "fmt"
//函数功能：求和
//函数的名字：getSum 参数为空
//getSum函数返回值为一个函数，这个函数的参数是一个int类型的参数，返回值也是int类型
func getSum() func (int) int {
        var sum int = 0
        return func (num int) int{
                sum = sum + num 
                return sum
        }
}
//闭包：返回的匿名函数+匿名函数以外的变量num
func main(){
        f := getSum()
        fmt.Println(f(1))//1 
        fmt.Println(f(2))//3
        fmt.Println(f(3))//6
        fmt.Println(f(4))//10
        fmt.Println("----------------------")
        fmt.Println(getSum01(0,1))//1
        fmt.Println(getSum01(1,2))//3
        fmt.Println(getSum01(3,3))//6
        fmt.Println(getSum01(6,4))//10
}
func getSum01(sum int,num int) int{
        sum = sum + num
        return sum
}
//不使用闭包的时候：我想保留的值，不可以反复使用
//闭包应用场景：闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了

5.7、defer关键字

5.8、系统函数

5.5 系统函数之日期和时间相关函数

5.6、系统函数只内置函数

第六章：错误处理

6.1、defer+recover机制处理错误

6.2、自定义错误

第七章：数组

7.1、数组的引入

7.2、内存分析

7.3、数组的遍历

7.4、数组的初始化方式

7.5、注意事项

7.6、二维数组

7.7、二维数组的遍历

package main
import "fmt"
func main(){
        //定义二维数组：
        var arr [3][3]int = [3][3]int{{1,4,7},{2,5,8},{3,6,9}}
        fmt.Println(arr)
        fmt.Println("------------------------")
        //方式1：普通for循环：
        for i := 0;i < len(arr);i++{
                for j := 0;j < len(arr[i]);j++ {
                        fmt.Print(arr[i][j],"\t")
                }
                fmt.Println()
        }
        fmt.Println("------------------------")
        //方式2：for range循环：
        for key,value := range arr {
                for k,v := range value {
                        fmt.Printf("arr[%v][%v]=%v\t",key,k,v)
                }
                fmt.Println()
        }
}

第八章：切片

8.1、切片的引入

8.2、内存分析

8.3、切片的定义

8.4、切片的遍历

8.5、切片的注意事项

第九章：映射

9.1、map的引入

9.2、map的3种创建方式

package main
import "fmt"
func main(){

        //方式1：
        //定义map变量：
        var a map[int]string
        //只声明map内存是没有分配空间

        //必须通过make函数进行初始化，才会分配空间：
        a = make(map[int]string,10) //map可以存放10个键值对

        //将键值对存入map中：
        a[20095452] = "张三"
        a[20095387] = "李四"
        //输出集合
        fmt.Println(a)
        //-------------------------------------------------------
        //方式2：
        b := make(map[int]string)
        b[20095452] = "张三"
        b[20095387] = "李四"
        fmt.Println(b)
        //-------------------------------------------------------
        //方式3：
        c := map[int]string{
                20095452 : "张三",
                20098765 : "李四",
        }
        c[20095387] = "王五"
        fmt.Println(c)
}

9.3、map的操作

package main
import "fmt"
func main(){
        //定义map
        b := make(map[int]string)
        //增加：
        b[20095452] = "张三"
        b[20095387] = "李四"
        b[20098833] = "王五"
        //获取长度：
        fmt.Println(len(b))
        //遍历：
        for k,v := range b {
                fmt.Printf("key为：%v value为%v \t",k,v)
        }
        fmt.Println("---------------------------")
        //加深难度：
        a := make(map[string]map[int]string)
        //赋值：
        a["班级1"] = make(map[int]string,3)
        a["班级1"][20096677] = "露露"
        a["班级1"][20098833] = "丽丽"
        a["班级1"][20097722] = "菲菲"
        a["班级2"] = make(map[int]string,3)
        a["班级2"][20089911] = "小明"
        a["班级2"][20085533] = "小龙"
        a["班级2"][20087244] = "小飞"
        for k1,v1:= range a {
                fmt.Println(k1)
                for k2,v2:= range v1{
                        fmt.Printf("学生学号为：%v 学生姓名为%v \t",k2,v2)
                }
                fmt.Println()
        }
}

第十章：面向对象

10.1、面向对象的引入

10.2、结构体

10.3、内存分析

10.4、结构体实例的创建方式

10.5、结构体之间的转换

10.6、结构体方法

第十一章：