第二十一章、GORM

        一、ORM介绍

            1.1 Gin框架简介

            中文官方文档：https://gorm.io/zh_CN/

            GORM是Golang目前比较热门的数据库ORM操作库，对开发者也比较友好，使用非常方便简单，使用上主要就是把struct类型和数据库表记录进行映射，操作数据库的时候不需要直接手写Sql代码，这里主要介绍MySQL数据库。

            1.2 安装

            go get gorm.io/gorm                 安装最新版本  go get -u gorm.io/gorm

            go get  gorm.io/driver/sqlite      安装最新版本  go get -u gorm.io/driver/sqlite

            1.3 ORM优缺点

            优点：提高开发效率

            缺点：牺牲执行性能、牺牲灵活性、弱化了开发者的SQL能力

        二、CURD操作

            2.1 链接数据库

            2.2 创建记录

            用指定的字段创建记录

            创建一个记录且忽略传递的字段值，创建结构体中 Omit()没有指定的字段值

            批量插入数据，将一个slice传给Create方法，GORM会生成一条单独的SQL语句插入所有数据，并填写回主键的值，钩子方法也会被调用

            分批插入数据

            2.3 默认值

            案例演示：

            2.4 查询

            1.5 约定

            GORM 倾向于约定，而不是配置。默认情况下，GORM 使用 ID 作为主键，使用结构体名的 蛇形复数 作为表名，字段名的 蛇形 作为列名，并使用 CreatedAt、UpdatedAt 字段追踪创建、更新时间

            遵循 GORM 已有的约定，可以减少您的配置和代码量。如果约定不符合您的需求，GORM 允许您自定义配置它们

第二十章、Gin框架

        一、Gin框架介绍

            1.1 Gin框架简介

            Gin 是一个用 Go (Golang) 编写的 Web 框架。 它具有类似 martini 的 API，性能要好得多，多亏了 httprouter，速度提高了 40 倍。 如果您需要性能和良好的生产力，您一定会喜欢 Gin。

        二、快速入门

            2.1 下载并安装gin

            go get -u github.com/gin-gonic/gin

            2.2 gin渲染HTML

            终端curl 命令发送请求

            2.3 自定义模板函数

            2.4 静态文件处理

            2.5 使用模板继承

            以下模板继承来自于网络其他方式：

            header文件：

            footer文件：

            extends文件：

            代码如下：

        三、gin框架返回数据

            3.1 获取URL参数

            3.1.1 通用处理方式Handle()方式

            3.1.2 分类处理engine.GET()        engine.POST()，POST表单默认解析方式x-www-form-urlencoded或from-data格式的参数

            3.2 多数据格式返回请求结果

            3.3 表单实体绑定

            3.4 Any路由的使用

            3.5 文件上传

            3.5.1 单文件上传

            3.5.2 多文件上传

            3.6 为不存在的路由配置处理函数

            3.7 日志记录进文件

        四、重定向

             4.1 HTTP重定向

             4.2 路由重定向

        五、路由分组

            4.1 路由分组

            4.2 简化路由分组

        五、中间件

            5.1 中间件

            案例演示一，所有API共用中间件：

            案例演示二，单独一个API使用中间件方式：

            5.2 context.Next函数，将中间件代码一分为二执行，执行完成相关调用以后回来继续context.Next()后面的处理函数

            案例演示：

            5.3 context.Abort函数，阻止调用处理函数

            页面没有反馈，空白

            5.5 context.Abort函数和context.Next函数应用

            5.6 路由组注册中间件

            5.7 中间件注意事项

第十九章、Go模板渲染

        一、Go原生模板渲染

            1.1 Go原生模板解析、模板渲染

            1.2 模板语法

            多个变量渲染

            1.3 模板中的注释

            1.4 pipeling

            1.5 变量

            1.6 移除空格

            1.7 条件判断

            1.8 range遍历

            1.9 with

            1.20 比较函数

            1.21 预定义函数

            案例演示：

            1.22 原生模板嵌套

            1.23 block使用

            案例演示：

            1.24 修改默认标识符

            1.25 转义js代码，防止xss攻击

第十八章、数据操作

        一、golang操作mysql

            1.1 安装第三方库

            进入到项目的src目录下，在终端执行：go get github.com/go-sql-driver/mysql

            1.2 连接mysql    sql.Open()

            1.3 往mysql写入数据DB.Exec()

            1.4 查询数据

            单行查询：db.QueryRow()

            多行查询：db.Query()

            1.5 更新数据DB.Exec()

            1.6 删除数据DB.Exec()

            1.7 mysql预处理 func (db *DB) Prepare(query string) (*stmt,error)

            一、预处理查询

            二、预处理添加、删除、编辑语句类似

            1.8 mysql事务DB.Begin()    DB.Commit()    DB.Rollback()

            1.9 演示sql注入     注意：任何时候，都不应该在项目中拼接SQL语句！！！

        二、golang操作sqlx库

            2.1 sqlx库基本介绍

            sqlx是 Go 的软件包，它在出色的内置database/sql软件包的基础上提供了一组扩展。

            该库兼容sql原生包，同时又提供了更为强大的、优雅的查询、插入函数。

            该库提供四个处理类型，分别是：

            sqlx.DB – 类似原生的 sql.DB；sqlx.Tx – 类似原生的 sql.Tx；sqlx.Stmt – 类似原生的 sql.Stmt, 准备 SQL 语句操作；sqlx.NamedStmt – 对特定参数命名并绑定生成 SQL 语句操作。

            提供两个游标类型，分别是：

            sqlx.Rows – 类似原生的 sql.Rows, 从 Queryx 返回；sqlx.Row – 类似原生的 sql.Row, 从 QueryRowx 返回。

            2.2 安装第三方库

            进入到项目的src目录下，在终端执

            2.3 链接数据库   sqlx.Connect()

            2.4 单行查询Db.Get()

            2.5 多行查询Db.Get()

            2.6 Db.NameEcex()方法用来绑定SQL语句与结构体或map中的同名字段

            2.7 注意事项

第十七章、网络编程

        一、网络编程基本介绍

            golang的主要设计目标之一就是面向大规模后端服务程序，网络通信是服务端程序必不可少的。

            1.1、网络编程两种方式：

            a、TCP socket编程，是网络编程的主流，之所以叫TCP socket编程，是因为底层基于TCP/IP协议的，比如：QQ

            b、B/S结构的HTTP编程，我们使用浏览器去访问服务器时，使用的就是http协议，而http底层依旧是用TCP socket实现的，比如：京东商城

        二、TCP/IP协议

            TCP/IP(Transmission Control Protocol/Internet Protocol)的简写，中文名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议，Internet国际互联网络的基础，简单的说，就是由网络层的IP协议和传输层的TCP协议组成

            2.1、OSI与TCP/IP参考模型

            2.2、网线、网卡、无线网卡

            2.3、聊天工具案例

            2.4、IP地址

            2.5、端口介绍

             使用Telnet链接IP和端口：

             第一步、win10搜索控制面板

             第二步、点击启用或关闭windows功能

             第三步、安装Telnet

             第四步、使用telnet IP 端口号   ； ctrl + ] 退出，quit退出...

            2.6、TCP Socket编程的客户端和服务器端

            2.7、TCP Socket编程入门案例

            要求：

            分析：

            服务端：

            服务端代码：

            客户端代码：

            改进：

        三、Redis基本介绍

            3.1、需求分析

            3.2、技术储备-redis 

            3.2.1、redis 基本介绍

            3.2.2、redis安装和基本使用

            操作原理图：

            链接redis：

            3.2.3、redis操作指令一览

            网址：http://redisdoc.com/

            3.2.4、redis的基本使用

            3.3、Redis的CURD

            3.3.1、Redis的五大数据类型

            String(字符串)、Hash(哈希)、Lish(链表)、集合(Set)、有序集合(Zset)

            String基本介绍：

            a、String是redis最基本的类型，一个key对应一个value

            b、String类型是二进制安全的，除普通字符串外，也可以存放图片等数据；单个value最大值512M

            c、set操作，set[如果key存在就相当于修改，如果不存在相当于添加]；set key value;

            d、get操作，直接 get key键

            e、del操作，直接del key键

            f、set设置过期时间， setex  key  过期时间 value

            g、mset同时设置一个或多个 key-value对，如果给定的key已经存在，那么mset会用新值覆盖原来的旧值，格式：mset key1 value1 key2 value2，可以使用mget 获取全部值   也可以单独使用get 指定的键

            Hash基本介绍（hash类似golang里面的map）：

            a、Redis hash是一个键值对集合

            b、Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象

            c、设置指令格式： hset key field value    

            d、获取指令格式： hget key field 

            e、获取所有： hgetall key

            f、一次性设置所有：hmset key field value field value ...

            g、一次性获取所有：hmget key field field ...

            h、删除指定字段：hdel key field

            i、hlen统计一个hash有几个元素

            j、查看hash表key中，是否存在给定的field字段，指令格式：hexists key field

            List(列表)基本介绍：

            列表是简单的字符串列表，按照插入顺序排序，你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

            List本质十个链表，List的元素是有序的，元素的值可以重复。

            List数据结构分析：

            a、设置一个链表，从左边插入：lpush key value value value ...    依次放入aaa  bbb  ccc

            b、获取链表内容，从左边“取出”（只是取出，链表中还存在这个数据）：lrange key start stop ,这里的start代表开始，stop代表结束，当stop为-1的时候表示取到最后一个值，lrange key 0 -1，表示全部取出；依次取出 ccc  bbb  aaa  

            c、设置一个链表，从右边插入：rpush key value value value ...    依次放入ddd  eee

            此刻再从左边取出， 看看数据结构：

            d、从链表左边“弹出”（从链表中弹出移走数据）：lpop key

            e、从链表右边“弹出”（从链表中弹出移走数据）：rpop key

            f、删除整个链表：del key

            注意事项：

            a、lindex  ：按照索引下标获得元素（从左到右，编号从0开始）

            b、LLEN key ：返回列表key的长度，如果key不存在，则key被解释为一个空列表，返回0

            c、List数据，可以从左 或者从右插入添加

            d、如果值全移除，对应的键也就消失了

            Set(集合)基本介绍：

            Redis的Set是string类型的无序集合，底层是Hash Table数据结构，Set也是存放很多字符串元素，字符串元素是无序的，而且元素的值不能重复

            a、添加数据到集合中：sadd key member member member ...   (member：成员)

            b、从集合中取出所有数据：smembers key

            c、判断值是否是成员：sismember  key  member 

            d、删除集合中指定的成员：srem key member

            注意事项：

            a、元素的值不能重复

            3.3、Golang操作Redis

            3.3.1、安装第三方开源redis库

            golang下载第三方扩展库：

            https://github.com/gomodule/redigo

            安装：进入到gopath目录下，在终端执行：go get github.com/gomodule/redigo/redis

            3.3.2、String类型数据操作

            3.3.3、Hash类型数据操作

            3.3.4、Redis连接池基本介绍

            a、事先初始化一定数量的链接，放入到连接池

            b、当Go需要操作Redis的时候，直接从Redis连接池取出链接即可

            c、可以节省零时获取Redis链接的时间，从而提高效率

            d、示意图

            核心代码：

            连接池使用案例：

        四、用户即时通讯系统

            4.1、需求分析

            4.2、功能一，显示客户端菜单

            4.3、功能二，完成用户登录

            4.4、功能三，完成客户端可以发送消息本身，服务端可以正常接收到消息，并根据客户端发送的消息判断用户的合法性，并返回相应的LoginResMes

            编译：去到项目的根目录执行，go build -o xxx.exe  从src下的目录开始直到文件所在的包

            服务端代码改进以后的框架结构图：

            客户端代码改进以后的框架结构图：

            4.5、功能四，在redis手动添加测试用户，并画图+说明

            输入的用户名在redis中存在则登录，否则退出系统并给出相应的提示(账号密码错误或者用户不存在)

第十六章、反射

        一、基本介绍

            1.1、反射的基本介绍

            反射使用到的包

            1.2、反射的概念

            示意图：

            1.3、先看一个问题，反射的应用场景

            场景一

            场景二

            1.4、反射快速入门案例

            1.4、反射使用注意事项和细节

            注意事项1：获取变量的类别，返回的是一个常量

            1.5、反射遍历结构体字段，调用结构体方法

            最佳实践1：

            案例演示：

            最佳实践2

            代码：

第十五章、goroutine和channel

        一、基本介绍

            1.1、什么是并行？

            在同一“时刻”，多件事情一起做；多线程程序在多核上运行，就是并行。特点：多个任务作用在多核CPU上，从微观的角度看，在同一时间点上，有多个任务在同时执行

            1.2、什么是并发？

            多线程程序在单核上运行，就是并发。特点：多个任务作用在一个CPU上；从微观的角度看，在一个时间点上只有一个任务在执行

            1.3、什么是线程？

            线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流。

            1.4、什么是进程？

            进程就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位，一个进程中可以创建和销毁多个线程，同一个进程中的多个线程可以并发执行，一个程序至少有一个进程，一个进程至少有一个线程。

            可以这么理解进程和线程，启动迅雷软件是一个进程，然后下载很多个电影资源就是多个线程；（程序加载到内存，运行起来就是进程）

            1.5、什么是go协程？

            Go主线程(有程序员直接称之为线程/也可以理解成进程)，一个Go线程上可以起多个协程，Go 协程可以看作是轻量级线程。与线程相比，创建一个 Go 协程的成本很小。因此在 Go 应用中，常常会看到有数以千计的 Go 协程并发地运行。

            “没有哪个程序是没有进程的”，Go协程的特点：

            1. 有独立的栈空间

            2. 共享程序堆空间

            3. 调度由用户控制

            4. 协程是轻量级的线程

        二、快速入门

            2.1、案例演示

            2.2、快速入门总结

            a、主线程是一个物理线程，直接作用在CPU上，是重量级的，非常耗费CPU资源

            b、协程是从主线程开启的，是轻量级的线程，是逻辑态的，对资源消耗相对较小

            c、golang的协程是重要的特点，可以轻松开启上万个协程，其他语言的并发机制一般是基于线程的；开启过多的线程，资源耗费大，这里就凸显golang在并发上的优势了

        三、Goroutine调度模型

            3.1、MPG基本模式介绍

            M（Machine）：操作系统的主线程

            P（Processor）：协程执行需要的资源（上下文context）

            G（Gorountine）：协程，有自己的栈。包含指令指针（instruction pointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G

            3.2、MPG模式运行状态1

            3.3、MPG模式运行状态2

            3.4、设置golang运行的CPU数

        四、channel(管道)

            4.1、完成下面需求

            执行ceshi.exe 结果如下：

            存在问题的代码：

            4.2、解决办法

            方法一：全局变量加锁同步改进程序

            原理：

            使用锁会用到的包：

            代码改进：

            方法二：channel通讯机制改进

            4.3、管道基本介绍

            4.3.1、管道示意：

            4.3.2、管道基本使用

            声明/定义channel：

            var 变量名  chan 数据类型   ！！！

            var perChan chan *Person

            var intChan  chan int

            var mapChan chan map[int]string    (用于存放map[int]string类型数据)

            说明：

            1.channel是引用类型

            2.channel必须初始化才能写入数据，即make后才能使用

            3.channel是有类型的，intChan 只能写入int类型数据

            演示管道的使用：

            4.3.3、channel使用注意事项

            a、channel中只能存放指定的数据类型

            b、channel中数据放满了就不能再往里面存放数据了

            c、如果从channel中取出数据以后就可以继续存放

            d、在没有使用协程的情况下，如果channel数据取完了，再取，就会报dead lock

            4.3.4、读写channel案例演示

            4.3.5、channel的遍历和关闭

            4.3.5、goroutine和channel协同工作

            需求：完成goroutine和channel协同工作

            1.开启一个writeData协程，向intChan中写入50个数据

            2.开启一个readData协程，从intChan中读取writeData写入的数据.

            注意：writeData和writeData操作的是同一个管道

            3.主线程需要等writeData和writeData协程完成工作才能退出

            4.3.6、goroutine和channel  --  阻塞

            管道容量10，只向管道里面写入数据，写入50个数据，而没有读取，就会出现阻塞而deadlock！

            图1

            图2

            图3

            图4

            goroutine和channel应用3

            思路分析：

            代码：

            图一

            图二

            图三

            4.4、channel使用细节和注意事项

            a、channel可以声明为只读，或者只写性质

            b、使用select可以解决从管道读取数据的阻塞问题

            基本语法：

            c、goroutine中使用recover， 解决协程中出现panic，导致程序崩溃的问题

            错误代码：

            defer + recover

第十四章、单元测试

        一、基本介绍

            1.1、在工作中，我们经常会遇到这样的情况，就是去确认一个函数或者一个模块的结果是否正确，如：

            1.2、传统方式测试

            在main函数中，调用addUpper函数，看看实际输出的结果是否和预期的结果一致，如果一致则说明函数正确，不一致则函数有问题

            案例：

            分析：

            1、测试不方便， 我们要在main函数中去调用，这样就需要去修改main函数，如果项目正在运行，就有可能去停掉项目

            2、不利于管理，当我们测试多个函数或者多个模块时，都需要写在main函数，不利于我们管理和清晰思路

            3、引出单元测试，testing测试框架，可以很好的解决问题

            1.3、单元测试基本介绍

            1.3.1、单元测试基本入门

            1.3.2、单元测试基本原理

            1.3.3、单元测试总结

            a、测试用例文件名必须以_test.go结尾，如：cal_test.go，cal不是固定的

            b、测试用例函数必须以Test开头，一般来说就是Test+被测试的函数名，比如TestAddUpper(),Test后面的第一个字母必须大写

            c、TestAddUpper(t *testing.T)的参数类型必须是testing.T

            d、一个测试文件中可以有多个测试用例函数，比如TestAddUpper()   TestGetSub()等等   

            e、运行测试用例指令：

                命令行去到测试用例文件所在文件夹，执行go test，【如果运行正常，无日志；运行错误，输出日志】

                命令行去到测试用例文件所在文件夹，执行go test -v，【如果运行正常、错误，都会输出日志】

            f、当出现错误时，可以使用来格式化t.Fatalf() 输出信息，并退出程序

            g、t.Logf()方法可以输出相应日志        

            h、测试用例函数并没有放在main()函数中，也执行了，这就是测试用例函数的方便之处

            i、PASS表示测试用例运行成功，FAIL表示测试用例运行失败   

            j、测试单个文件，一定要带上被测试的源文件，go test -v cal_test.go cal.go

            k、测试单个方法，go test -v  -test.run TestAddUpper

            1.3.4、单元测试综合案例_练习

            代码：

第十三章、文件操作

        一、基本介绍

            1.1 概念

            文件在程序中是以流的形式来操作的

            1.2 File文件位置

            在开发中操作文件，经常会用到os.File结构体

            1.3 File文件读取操作

            a、打开文件

              b、关闭文件

            c、读取文件并显示在终端(带缓冲区的方式)

            d、直接读取文件内容

            1.4 File文件写操作

            a、使用带缓存的方式往文件中写入内容

            b、读取一个文件的内容，写入到另一个文件

            1.5 判断文件或文件夹是否存在

            1.6 将一个目录下的文件拷贝到另一个目录

            1.7 os.Args存储所有的命令行参数

            1.8 使用flag包来解析命令行参数的用法

            1.9 json基本介绍

            1.9.1、json应用场景介绍

            1.9.2、json工具站点：https://www.json.cn/

            1.9.3、json的序列化

            1.9.4、json的序列化案例演示

            1.9.5、json的tag标签的使用

            1.9.6、json反序列化

            案例演示

            说明：

            1. 在反序列化一个json字符串时，要确保反序列化后的数据类型和原来反序列化前的数据类型一致，比如结构体，字段数量和名字保持一致，不能多不能烧

            2. 如果json字符串是通过程序获取到的，则不需要再 " 转义处理了。

第十二章、面向“对象”编程

        一、结构体

            1.1 概念

            一个程序就是一个世界，有很多对象(变量)

            1.2 golang语言面向对象编程说明

            a、golang也支持面向对象编程(oop)，但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言，所以我们说golang支持面向对象编程特性是比较准确的。

            b、golang没有类(class)，go语言的结构体(struct)和其他编程语言的类(class)有同等的地位，可以理解golang 基于struct来实现OOP特性的。

            c、golang面向对象编程非常简介，去掉了传统语言的继承、方法重载、构造函数和析构函数，隐藏的this指针等等

            d、golang仍然有面向对象编程的继承、封装和多态特性，只是实现的方式和其他OOP语言不一样，比如继承：golang没有extends关键字，是通过匿名字段来实现的

            e、golang面向对象(OOP)很优雅，OOP本身就是语言类型系统的一部分，通过接口(interface)关联，耦合性低，也非常灵活。

            1.3 结构体

            对上图说明：

            a、将一类事务的特性提取出来(比如猫)，形成一个新的数据类型，就是一个结构体

            b、通过这个结构体，我们可以创建多个变量(实例/对象)

            c、事务可以是人类、商品、工具类...

            1.3 结构体和结构体变量的区别联系

            a、结构体是自定义的数据类型，代表一类事物

            b、结构体变量是具体的、实际的、代表一个具体变量

            1.4 结构体在内存的布局

            声明未赋值：

            结构体赋值以后：

            1.5 如何声明结构体

            1.5.1、声明

            1.5.2、字段/属性

            a、从概念或者叫法上看：结构体字段=属性=field

            b、字段是结构体的一个组成部分，一般是基本数据类型、数组、也可以是引用数据类型，比如前面我们定义的猫猫结构体，Name string就是属性

            1.5.3、字段/属性注意事项（结构体是值类型！！！）

            注意事项3：

            注意事项4：不同结构体字段是独立的，互不影响

            画出上面代码的内存示意图：

            第一步、值拷贝

            第二步、修改值

            1.5.4、创建结构体变量和访问结构体字段

            1.5.5、struct类型的内存分配机制

            1.5.6、结构体的注意事项和使用细节

            a、结构体的所有字段在内存中 是连续的

            b、结构体是用户单独定义的类型，和其他类型转换时需要有完全相同的字段(名字、个数和类型)

            c、结构体进行type重新定义(相当于取别名)，golang认为是新的数据类型，但是互相间可以强转

            d、struct的每个字段上，可以写上一个tag，该tag可以通过反射机制获取，常见的使用场景就是序列化和烦序列化

            案例演示：

        二、方法

            2.1 基本介绍

            2.2 方法的声明和调用

            上面代码说明：

            a、func (a A) test(){}    表示A结构体有一个方法，方法名test

            b、(a A) 体现test方法和A类型绑定

            案例演示：

            对上面代码总结：

            a、test()方法和类型Person5绑定

            b、test()方法只能通过Person5类型的变量来调用，而不能直接调用，也不能使用其他类型变量来调用

            c、func(p Person5)test(){},  p表示哪个Person5变量调用，这个p就是它的副本，这点和函数的传参非常相似

            d、p这个名字，由程序员指定，不固定

            练习案例：

            1.

            2.

            2.3 方法的调用和传参机制

            说明：方法的调用、传参机制和函数基本一样，不一样的地方是方法调用时，会将调用方法的变量，当做实参也传递给方法

            2.4 方法注意事项和细节

            a、结构体类型是值类型，在方法调用中，遵守值类型传递机制，是值拷贝传递方式

            b、如果程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理，通常也多用指针方式，程序运行效率更高

            内存说明：

            c、golang中的方法作用在指定类型上，(即：和指定的数据类型绑定)，因此，自定义类型都可以有方法，而不仅仅是struct，比如int、float64等等都可以

            d、方法的访问范围控制规则，和函数一样。方法名首字母小写，只能在本包访问，方法名首字母大写，可以在本包和其他包函数访问

            e、如果一个类型实现了String()这个方法，那么fmt.Println默认会调用这个类型的String()进行输出，一般可以用在日志记录

            2.5 方法和函数的区别

            a、调用方式不一样

            函数的调用方式：函数名(实参列表)

            方法的调用方式：变量.方法名(实参列表)

            b、对于普通函数，接收者为值类型时，不能将指针类型的数据传递，反之亦然

            c、对于方法，接受者为值类型时，可以直接用指针类型的变量调用方法，反过来同样可以

        三、面向对象编程应用实例

            3.1 步骤

            3.2 创建结构体变量时指定字段值

            3.3 工厂模式

            工厂模式解决结构体中结构体名字首字母小写问题：：

            如果结构体student的age字段首字母也是小写，在其他包不可以直接访问，我们可以提供一个方法

            3.4 面向对象编程思想-抽象

            简介：

            案例演示：

            3.5 面向对象编程的三大特性

            3.5.1 基本介绍

            golang仍然有面向对象编程的继承、封装、多态的特性，只是实现的方式和其他的OOP语言不一样

            3.5.2 封装：封装就是把抽象出来的字段和对字段的操作封装在一起，数据被保护在内部，程序的其他包只有通过被授权的操作(方法)，才能对字段进行操作

            封装的实现步骤：

            1、将结构体、字段的首字母小写(不能导出，其他包不能使用，类似private)

            2、给结构体所在的包提供一个工厂模式的函数，函数名首字母大写，类似一个构造函数

            3、提供一个首字母大写的Set方法

            4、提供一个首字母大写的Get方法

            特别说明：在golang开发中并没有特别强调封装，这点并不像java、PHP，golang本身对面向对象的特性做了简化的

            案例：

            3.5.3 继承：当多个结构体存在相同的属性(字段)和方法时，可以从这些结构体中抽象出这些结构体，在该结构体中定义相同的属性和方法，其他的结构体不需要重新定义这些相同的属性和方法，只需要嵌入一个(基础结构体的)匿名结构体就可以了；也就是说，一个结构体嵌套了另一个匿名结构体，那么这个结构体就可以直接访问匿名结构体的属性和方法，从而实现继承特性

            画图说明继承的特性：

            嵌套匿名结构体的基本语法：

            案例演示：

            继承给编程带来的便利：

            a、代码的复用性提高了

            b、代码的扩展性和维护性提高了

            继承深入讨论：

            a、结构体可以使用嵌套匿名结构体的所有字段和方法，即：首字母大写、小写的字段 方法都可以使用， 注意：：但是跨包不能访问小写字段和方法

            b、匿名结构体字段访问可以简化

            上图代码说明：

            c、当结构体和匿名结构体有相同的字段或方法时，编译器采用“就近原则”访问，如果希望访问匿名结构体的子弹和方法，可以通过匿名结构体来区分

            d、当结构体嵌入多个匿名结构体...

            e、如果一个struct嵌套了一个"有名结构体"，这种模式就是“组合”，如果是组合关系，那么在访问组合的结构体方法或字段时，必须带上结构体的名字 

            f、嵌套匿名结构体后，也可以在创建结构体变量(实例)时，直接指定各个匿名结构体字段的值

            指针方式：

            g、结构体中匿名字段使用

        四、接口

            4.1.1 golang接口简介

            interface类型可以定义一组方法，但是这些方法不需要实现，并且interface不能包含任何变量，到某个自定义类型(比如下面列子的结构体Phone)要使用的时候，再根据具体情况把这些方法写出来(实现)。

            4.1.2 基本语法

            4.1.3 为什么会有接口

            4.1.4 入门案例演示

            4.1.5 接口注意事项和细节说明

            a、接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量(实例)

            b、接口中所有的方法都没有方法体，即：都是没有实现的方法

            c、在golang中，一个自定义类型需要将某个接口的所有方法都实现，我们说这个自定义类型实现了该接口

            d、只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型

            e、一个自定义类型可以实现多个接口

            f、golang接口中不能有任何变量，编译不过，会报错

            g、一个接口(比如A接口)，“可以继承多个”别的接口(比如B、C接口)，这时如果要实现A接口，必须将B、C接口的方法全部实现

            h、interface类型默认是一个指针(引用类型)，如果没有对interface初始化就使用，那么会输出nil

            i、空interface{}没有任何方法，所以，所有类型都实现了空接口(换句话说就是，我们可以把任何数据类型的变量赋值给空接口)

            4.1.6 接口编程实践

            4.1.7 实现接口 vs 继承

            案例演示：

            说明：

            a、当结构体B继承了结构体A，那么结构体B就自动的继承了结构体A的字段和方法，可以直接使用

            b、当B结构体需要扩展功能，同时不希望破坏继承关系，则可以去实现接口，因此我们认为：实现接口是对继承的补充！！！

            4.1.8 接口 和 继承的区别

        五、面向对象编程-多态

            5.1.1 基本介绍

            变量(实例)具有多种形态，在go语言中，多态特征是通过接口来实现的，可以按照统一的接口来调用不同的实现，这时接口变量就呈现不同的形态。

            5.1.2 接口体现多态的两种形式

            案例演示：

            5.1.3 类型断言基本介绍

            类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型，就需要使用类型断言

            如何在断言时，带上监测机制，如果成功就ok，否则也不要报panic

            5.1.4 类型断言实践

            第一题、usb接口案例

            第二题、写一个函数， 循环判断传入参数的类型

第十一章、go内置函数以及错误处理

        11.1 go内置函数

                1、内置函数简介

                golang设计者为了编程方便，提供了一些函数，这些函数可以直接使用，我们称之为内置函数(也叫内建函数)，https://studygolang.com/pkgdoc -> builtin包

                2、一些常用内置函数

                len()函数

                new()函数：用来分配内存，主要用来分配值类型，比如：int、float、struct...  返回的是指针 

                内存分配示意图：

                make()函数：用来分配内存，主要是用来分配引用类型，比如chan、map、slice

        11.2 golang错误处理

                11.2.1 看一段代码

                说明：

                a、在默认情况下，当发生错误(panic)后，程序就会退出(崩溃)

                b、如果我们希望：在发生错误后可以捕捉到错误，并进行处理保证程序可以继续执行，可以在捕捉到错误以后，给管理员发送邮件或者短信...

                c、这里引出错误处理机制

                11.2.2 golang错误处理基本说明

                案例：

                错误处理的好处：进行错误处理后，程序不会轻易挂掉，如果加入预警代码，就可以让程序更加的健壮

        11.3 自定义错误处理

                11.3.1 在go中也支持自定义错误，使用errors.New和panic内置函数

                第一步、errors.New("错误说明"),会返回一个error类型的值表示一个错误

                第二步、panic内置函数，接收一个interface{}类型的值(也就是任何值)作为参数，可以接收error类型的变量，输出错误信息，并退出程序

第十章、go中常用函数

        10.1 字符串中常用系统函数

                1、统计字符串长度（字节），len(str)

                2、统计字

                字符串遍历，同时处理有中文的问题  r:=[]rune(str)

                3、字符串转整数  n,err := strconv.Atoi()

                4、整数转字符串  str := strconv.Itoa(632)

                5、字符串转[]byte    var bytes = []byte("abds")

                6、[]byte转字符串   str := string([]byte{97,98,99})

                7、十进制转2,8,16进制   str = strconv.FormatInt(i int64, base int) string

                8、查找子串是否在指定的字符串：

                9、统计一个字符串有几个指定的子串   strings.Count("cheseese","e")

                10、不区分大小写的字符串比较(==是区分字母大小写的)    strings.EqualFold("ab","Ab")

                11、返回子串在字符串第一次出现的index值（位置），如果没有返回-1   strings.Index("FDJ_abc","abc")

                12、返回子串在字符串最后出现的位置，如果没有则返回-1  strings.LastIndex("go golanmg","go")

                13、将指定的子串替换成另一个子串strings.Replace("go go go hello","go","go语言",n)，n可以指定你希望替换几个，如果n<0 表示全部替换

                14、按照指定的某个字符 为分割标识符，将一个字符串拆分成字符串数组strings.Split("hello,world,ok",",")

                15、将字符串的字母进行大小写转换strings.ToLower("Go") //strings.ToUpper("Go") //GO

                16、将字符串左右两边的空格去掉 strings.TrimSpace(" ds a long ntr ")

                17、将字符串左右两边指定的字符去掉strings.Trim("! hello !"," !")

                18、将字符串左边指定的字符去掉strings.TrimLeft("!hello!","!")

                20、判断字符串会否以指定的字符串开头strings.HasPrefix("ftp://192.168.3.1","ftp") //true

                21、判断字符串会否以指定的字符串结尾strings.HasSuffix("qaq.jpg","jpg")

        10.2 时间和日期相关函数

                10.2.1、简介：时间和日期相关函数，需要导入time包

                10.2.2、time.Time类型用于表示时间

                10.2.3、获取其他的日期信息

                10.2.4、格式化日期和时间

                a、使用Printf或者Sprintf

                b、Format函数格式化

                说明：

                使用format函数，参数“2006/01/02 15:04:05”这个字符串是固定式，必须这样写，据网上流传是go语言设计者想设计一门新语言想法的最初时间；这个字符串的格式可以改变，但是数字数据不能改变

                10.2.5、时间的常量

                不能在时间单位后面去除一个数 ，只能用时间单位乘以一个数字来表示要表达的时间

                案例演示，配合sleep(休眠)做如下练习，func Sleep(d Duration) time.Sleep(100 * time.Millisecond) 表示100毫秒

                10.2.6、获取当前unix时间戳和unixnano时间戳(作用是可以获取随机数字)

                练习：

第九章、函数

        9.1 函数基本介绍

                函数是为完成某一功能的程序指令(语句)的集合，称为函数。在go中，函数分为自定义函数和系统函数。

        9.2 函数基本语法

                基本语法如下：   

                案例：

        9.3 go中的包

                9.3.1 包的基本概念

                go的每一个文件都是属于一个包的，也就是说go是以包的形式来管理文件和项目目录结构的

                9.3.2 包的引出

                在实际的开发中，我们往往需要在不同的文件中，去调用其他文件定义的函数，比如在main.go中去使用utils.go中的函数  

                9.3.3 包的原理

                包的本质：实际上就是创建不同的文件夹，来存放程序文件

                9.3.4 包的三大作用

                a、区分相同名字的函数、变量等标识符

                b、当程序文件较多时，可以很好的管理项目

                c、控制函数、变量等访问范围，即作用域

                9.3.5 打包基本语法

                package 包名

                9.3.6 引入一个包

                import "包的路径"

                9.3.7 包的快速入门，调用包中的函数

                案列：

                9.3.8 包的注意事项和细节说明

        9.4 函数的调用机制

                9.4.1 基本介绍

                9.4.2 golang中，函数调用机制的底层分析

                1. 第一步，主函数n1赋值，主函数中去调用test()函数；在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理让这个新的空间和其他栈的空间区分开来

                2. 第二步，test()函数执行完毕，终端输出n1=11,编译器回收test()函数里面的变量；在每个函数对应的栈中，数据空间是独立的，不会混淆；当一个函数执行完毕，程序会销毁这个函数对应的栈空间

                3. 第三步，main()函数也执行完毕，终端输出test()中的n1=11，main()函数的n1=10，编译器回收main()函数里面的n1变量

                9.4.3 案例演示

                9.4.4 函数中return 语句介绍

        9.5 递归函数

                9.5.1 递归函数简介

                一个函数在函数体内又调用了本身，我们称为递归调用

                案例演示：

                过程分析图：

                递归调用的总结：

                9.5.2 递归练习题

                练习1：请使用递归的方式，求出斐波拉契数    1，1，2，3，5，8，13，21...

                练习2：习题如下

        9.6 函数注意事项和细节讨论

                案例演示第6：

                第一步、

                第二步、

                案例演示第6、第8：

                案例演示第10：

                案例11：

                案例演示第13：

        9.7 init函数

                9.7.1 基本介绍

                每一个源文件都可以包含一个init函数，该函数会在main函数之前执行，被go运行框架调用，也就是说init函数会在main函数之前被调用

                9.7.2 案例演示

                9.7.3 细节讨论

                a、如果一个文件同时包含init函数、main函数、全局变量定义，则执行的流程顺序是全局变量定义 -> init函数 -> main函数

                a、init函数的主要作用，就是完成一些初始化工作

                案例如下：

                a、如果主函数main.go  和初始化函数init.go中都含有变量定义，执行的流程又是怎么样的呢？

        9.8 匿名函数

                9.8.1 基本介绍

                Go支持匿名函数，如果我们某个函数只希望使用一次，可以考虑使用匿名函数匿名函数也可以实现多次调用

                9.8.2 匿名函数使用方

                使用式1：

                在定义匿名函数时就直接调用这种方式匿名函数只能调用一次

                使用式2：

                将匿名函数赋值给一个变量(函数变量)，再通过该变量来调用匿名函数

                9.8.3 全局匿名函数

                如果将匿名函数赋值给一个全局变量，那么这个匿名函数就是一个全局匿名函数

        9.9 闭包函数

                9.8.1 基本介绍

                闭包就是“一个函数”和“与其相关的引用环境”组合的“整体(实体)”

                9.8.2 案例演示1

                对上面代码说明和总结：

                1、AddUpper()是一个函数，返回的数据类型是 func(int) int

                2、闭包的说明：返回的是一个函数， 返回的是这个匿名函数，但是和这个匿名函数引用到了函数外面的变量n，因此这个匿名函数就和n形成一个整体，构成闭包

                3、可以这样理解：闭包是一个类，函数是操作，n是字段，函数和它使用到的n构成闭包

                4、当我们反复调用f函数时，因为n是初始化一次，因此每调用一次就进行累计

                5、我们要搞清楚闭包的关键，就是要分析出返回的函数它使用(引用)到哪些变量，因为函数和它引用到的变量共同构成闭包

                案例演示2

                代码说明：返回的匿名函数和makeSuffix(suffix string)的suffix变量组成一个闭包，因为返回的函数引用到suffix这个变量            

                闭包的好处：闭包可以把匿名函数引用到的变量保存(引用)下来，进行下次调用回

        9.10 函数中的defer

                9.10.1 基本介绍

                在程序中，程序员经常需要创建资源，(比如：数据库链接、文件句柄、锁等~)，为了再函数执行完毕后，及时的释放资源，go的设计者提供defer延时机制

                9.10.2 案例说明

                9.10.3 defer细节说明

                a、当go执行到一个defer时，不会立即执行defer后的语句，而是将defer后的语句压入到一个栈中，然后继续执行函数下一个语句

                b、当函数执行完毕以后，再从defer栈中依次从栈顶取出语句执行，注意：(入栈先入后出机制)

                c、在defer将语句入栈时，也会将相关的值拷贝同时入栈！！！ 

                d、函数中，defer的最佳实践！！！！！！！！！！

        9.11 函数参数的传递方式

                9.11.1 基本介绍

                值类型默认就是值传递，而引用类型参数默认就是引用传递

                其实，不管是值传递还是引用传递，传递给函数的都是变量的副本，不同的是值传递的是值的拷贝，而引用传递的是地址的拷贝，一般来说，地址拷贝效率高，因为数据量小，而值拷贝决定拷贝的数据大小，数据越大，效率越低

                9.11.2 值类型和引用类型

                值类型：基本数据类型int系列、float系列、bool、string、数组和结构体struct

                引用类型：指针、slice切片、map、管道chan、interface等都是引用类型

                3）如果希望函数内的变量能改变函数外的变量，可以传入变量的地址，(&num)，函数内以指针的方式操作变量

        9.12 变量作用域

                9.12.1 基本介绍

                a、函数内部声明/定义的变量叫局部变量，作用域仅限于函数内部 

                b、函数外部声明/定义的变量叫全局变量，作用域在整个包都有效，如果其首字母大写，在整个程序有效

                9.12.2 案例演示

                注意：：：

第八章、程序流程控制

        8.1、程序流程控制介绍

        8.2、顺序结构语句

        8.3、分支结构语句

                8.3.1 单分支结构

                基本语法如下：

                举例：

                注意事项：

                go 语句的if 后面必须是一个条件表达式，不能是赋值语句

                8.3.2 双分支结构

                基本语法如下：

                举例：

                8.3.3 多分支结构

                基本语法如下：

                流程图：

                案例：

                注意事项：多分支流程图中 任何时候只会有一个分支会有输出结果，走到那一块就结束了

                8.3.4 多分支结构

                举例：

        8.4、switch分支结构语句

                8.4.1 switch简介

                8.4.2 switch流程图

                8.4.3 举例

                8.4.4 注意事项：

                注意：

                8.4.5 switch和if的比较

        8.5、for循环控制语句

                8.5.1 for循环语句简介

                8.5.2 for循环流程图

                8.5.3 for循环使用细节

                8.5.4 举例

        8.6、go中没有while和do...while的实现

                8.6.1 for循环实现while效果

                案例：

                8.6.2 for循环实现do...while效果

                案例：

        8.7、多重循环

                8.7.1 基本介绍

                案例1：

                案例2：

                代码如下：

        8.8、跳转控制语句break

                8.8.1 基本语法介绍

                8.8.2 流程图

                8.8.3 案例

                8.8.4 break使用细节

                说明：

                break 默认跳出最近的一层for循环

                break 后面可以指定标签，跳出标签对应的for循环

        8.9、跳转控制语句continue

                8.9.1 基本语法介绍

                continue语句用于结束本次循环，继续执行下一次循环

                8.9.2 continue流程图

                8.9.3 案例

        8.10、跳转控制语句goto

                8.10.1 基本介绍

                8.10.2 案例

        8.11、跳转控制语句return

                8.11.1 基本介绍

                return使用在方法或者函数中，表示跳出所在的方法或函数。

                说明：

                1、 如果return是在普通的函数中，则表示跳出该函数，既不再执行函数中return后面的代码，也可以理解成终止函数。

                2、如果return是在main函数，表示终止main函数，也就是说终止程序。

第七章、Golang运算符

        1、Go语言运算符

            1.1 基本介绍

                介绍：运算符是一种特殊的符号，用于数值的运算、赋值、比较等.

                算术运算符：                   + - * / 取模

                赋值运算符：                   = += -= *= /= 

                比较运算符/关系运算：    == != >=  <= > <

                逻辑运算符：                   与 或 非

                位运算符：                      位与   位或  位异或  位左移   位右移

                其他运算符：                   取址运算符 &    取值运算符 *

            1.2 算术运算符

                介绍：对数值类型的变量进行运算，如加减乘除

                演示/的使用：

                演示%的使用：

            1.2.1 算术运算符使用注意事项

    a、对于除号 "/"，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。  例如：  x := 19/5 ,结果是3

                b、当对一个数取模时，可以等价 a%b = a-a/b*b  ， 这样我们可以看到 取模的一个本质运算。

                c、对Golang 的自增自减只能当做一个独立语言使用时，不能这样使用 b := a++  或者 b := a--

                d、Golang的++和--只能写在变量的后面，不能写在变量的前面， 没有 --a   ++a 这样的写法

                e、Golang设计者去掉了C/java中容易混淆的自增自减的写法，让Golang 更加简介 统一

            1.2.2 算术运算符练习

            1.3 关系运算符(比较运算符)

                介绍：关系运算符的结果都是bool型，要么是true 要么是false

                          关系表达式经常用在if结构的条件中或循环结构的条件中

            1.3.1 关系运算符使用细节

                a、关系运算符的结果都是bool型，要么是true 要么是false

                b、关系运算符组成的表达式，我们称为关系表达式，如 a > b

                c、比较运算符"==" 不能写成 "="

            1.4 逻辑运算符

                介绍：用于连接多个条件(一般来讲就是关系表达式)，最终的结果也是bool值

                练习：

            1.4.1 逻辑运算注意事项和细节说明

                  &&也叫短路与，如果第一个条件为false，则第二个条件不会判断，结果为false

                  ||也叫短路或，如果第一个条件为true，则第二个条件也不会判断，结果为true 

            1.5 赋值运算符

            1.5.1 赋值运算符介绍

            1.5.2 例子

            1.5.3 赋值运算符特点

                a、运算顺序从右到左

                b、赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值等

            1.6 运算符优先级

            1.6.1 位运算符

                golang中的位运算符：

                举例：

                计算过程：

                移位注意事项：

            1.6.2 位运算符

                举例实现三元运算符效果：

            1.7 键盘输入语句

            1.7.1 介绍：在开发中，需要接收到用户输入的数据，就需要使用键盘输入语句来获取

            1.7.2 步骤

                a、导入fmt包

                b、调用fmt包的函数，fmt.Scanln()  或者fmt.Scanf()

            1.7.3 需求：从控制台接收用户信息，年龄、姓名、薪水、是否通过考核

                方式一、fmt.Scanln()

              方式二、fmt.Scanf()

            1.8 计算机基础进制转换

                1.8.1 基数简介

                进制其实就是基数，大于或等于基数时，向高位进1。10进制基数就是10，二进制基数就是2，八进制（8）、十六进制（16）。

                1.8.2 原码、反码、补码

第六章、Golang标识符

        1、标识符的命名规范

            1.1 基本介绍

                a、对Golang对各种变量、方法、函数等命名时使用的字符序列称为标识符

                b、凡是自己可以起名字的地方都叫标识符，比如：var num int    var name string都是标识符

            1.2 标识符的命名规则

                a、由26个大小写英文字母、0-9、_组成

                b、数字不能开头

                c、golang中严格区分大小写

                d、标识符不能包含空格

                e、下划线“_”本身在go中是一个特殊的标识符，称为空标识符，可以代表其他任何的标识符，但是它对应的值会被忽略(比如忽略某个返回值)，所以仅能被作为占位符使用，不能作为标识符使用

                f、中文在go中定义变量的时候不会报错，编译也通过，但是定义go变量的时候不推荐使用中文

                f、不能以系统保留的关键字作为标识符，比如 if 、break等等...

            1.3 标识符案列

            1.4 标识符命名注意事项

                a、包名：保持package的名字尽量和目录一致，尽量采用有意义的包名；简短有意义，不要和标准库冲突

                b、变量名、函数名、常量名：采用驼峰法，比如：var  studentName string = "暗夜猎手薇恩"；  var goodsPrice float64 = 15.5

                c、如果变量名、函数名、常量名首字母大写，则可以被其他的包访问，如果首字母小写，则只能在本包中使用（注：可以理解成，首字母大写是公有的，首字母小写是私有的，其他编程语言的关键字public、 pricate、protected...  golang中没有public、 pricate、protected...等关键字）

                例子：

        2、系统保留关键字

        3、系统的预定义标识符

第五章、Go派生/复杂数据类型

        1、指针类型

            1.1 基本介绍

                a、对于基本类型来说，变量存的就是值，也叫值类型，基本数据类型在内存中的布局如下：

                b、获取变量的地址，使用&符号。比如，var i int = 10，获取i的地址：&i

                c、指针类型，指针变量存的是一个地址，这个地址指向的空间才是存的值；比如：var ptr *int = &num     在这里，带了* ptr是一个指针，没带*，ptr是整数。举例：指针在内存的布局

                d、获取指针类型所指向的值，使用 *，比如：var ptr *int ，使用*ptr获取ptr指向的值

            1.2 案例演示

                1.2.1 写一个程序，获取一个int变量num的地址，并显示在终端

                1.2.2 将num的地址赋值给指针ptr，并通过ptr去修改num的值

            1.3 指针细节说明

                a、值类型，都有对应的指针类型，形式为 *数据类型，比如int对应的指针类型就是 *int；*float32对应的指针类型就是 *float32;按此类推

                b、值类型包括：基本数据类型int系列、float系列、bool、string、数组和结构体struct

        2、值类型和引用类型

            2.1 常见的值类型和引用类型

                值类型：基本数据类型int系列、float系列、bool、string、数组和结构体struct

                引用类型：指针、slice切片、map、管道chan、接口interface等都是引用类型

            2.2 值类型和引用类型使用特点

                值类型：变量直接存储，内存通常在栈中（一般生命周期短的分配在栈区，但不绝对是，变量在别的函数用到，有可能放堆区，逃逸了）分配

                引用类型：变量存储的是一个地址，这个地址对应的空间才是真正存储的数据（值），内存通常在堆（一般生命周期长的分配在堆区，但不绝对是）上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收

                内存栈区和堆区示意图：

        3、数组

            3.1 基本介绍

                数组可以存放多个同一类型数据，数组也是一种数据类型，在Go中，数组是值类型

            3.2 数组定义和访问数组元素

                方式一、

                var 数组名 [数组长度]数据类型

                var chicken [5]float64

                赋值：chicken[0] = 10  chicken[1] = 20

                方式二、

                变量名 := [数组长度]数据类型{元素值1，元素值2，...} 

                a := [3]int{10,20,30}

                其他方式：：

                var chicken [3]int = [3]int{10,20,30}

                var chicken  = [3]int{10,20,30}

                var chicken  = [...]int{5,6,7}

                指定元素值对应下标

                var name = [3]string{1:"tom",2:"LeSeein",3:"yasuo"}

                访问数组中元素：chicken[0]     chicken[2]  

            3.3 数组在内存的布局

                说明：

                a、数组地址可以使用&  取地址获得

                b、数组的第一个元素的地址就是数组的首地址

                c、数组的各个元素的地址间隔是依据数据的类型决定的，比如int 64位系统占用8个字节

                案例演示：

            3.4 数组遍历

                方式一：for循环遍历

                方式二：for - range方式遍历

                案例：

            3.5 数组使用细节和注意事项

                a、数组是多个相同类型数据组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化

                b、var  arr []int ，这时候arr是一个slice切片

                c、数组中的元素可以试任何数据类型，包括值类型和引用类型，但是不能混合使用

                d、数组在创建后没有赋值是有默认值的(零值)，数值类型默认0 ， 字符串类型默认空字符串，bool数组默认false

                e、使用数组的步骤： 1.声明数组并开辟空间   2.给各个元素赋值  3.使用数组

                f、数组的下标是从0开始的

                g、数组下标必须在指定范围内使用，否则报panic：数组元素超出长度，比如var arr [3]int，则有效下标为[0-2]

                h、在Go中，数组属于值类型，在默认情况下是值传递，因此会进行值拷贝，数组间不会互相影响

                主函数：

                test函数：

                数组值拷贝内存详解：

                i、如果在其他函数中想修改原来数组的值，可以使用引用传递(指针方式)

                函数中修改数组值内存详解：

                j、长度是数组类型的一部分，在传递函数参数时，需要考虑数组的长度

            3.6 数组应用案例

            3.7 多维数组

                3.7.1 二维数组介绍(这里只介绍二维数组)

                3.7.2 二维数组声明、赋值

                3.7.3 二维数组应用

                3.7.4 二维数组在内存的形式

        4、切片

            4.1 在go中为什么需要切片？

            假如我们需要一个数组来保存学生成绩，但是学生人数不确定的情况又该怎么办呢？  解决方案：使用切片！！！ 

            4.2 切片的基本介绍

            a、切片的英文是slice

            b、切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制

            c、切片的使用和数组类似，遍历切片、访问切片的元素和求切片的长度len(slice)都一样

            d、切片的长度是可以变化的，因此切片是一个可以动态变化的数组

            e、切片定义的基本语法

                var 切片变量名 []类型，比如：var num []int           

            4.3 切片在内存中的形式

            4.4 切片的使用

            方式一、定义一个切片，然后让切片去引用一个已经创建好的数组，

            方式二、通过make来创建切片，基本语法：var 切片名 []type = make([],len,cap)

            说明：type:数据类型   len：大小      cap：指定切片容量，可选，如果分配了cap，则要求cap >= len

            内存布局：

            以上两种方式轻易切片的区别：

            a、通过make方式创建的切片可以指定切片的大小和容量

            b、如果没有给切片的各个元素赋值，那么就会使用默认值[int、float=>0  string=>""   bool=>false]

            c、通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素

            方式三、定义一个切片，直接指定具体数组，使用原理类似make的方式

            4.5 以上前两种方式的区别

            a、方式一时直接引用数组，这个数组是事先存在的，程序员是可见的

            b、方式二是通过make来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的，make创建的切片示意图如下：