包（package）是多个Go源码的集合，是一种高级的代码复用方案，Go语言为我们提供了很多内置包，如fmt、strconv、strings、sort、errors、time、encoding/json、os、io等。

Golang中的包可以分为三种：1、系统内置包 2、自定义包 3、第三方包

• 系统内置包：Golang 语言给我们提供的内置包，引入后可以直接使用，如fmt、strconv、strings、sort、errors、time、encoding/json、os、io等。
• 自定义包：开发者自己写的包
• 第三方包：属于自定义包的一种，需要下载安装到本地后才可以使用，如前面给大家介绍的 "github.com/shopspring/decimal"包解决float精度丢失问题。

在Golang1.11版本之前如果我们要自定义包的话必须把项目放在GOPATH目录。Go1.11版本之后无需手动配置环境变量，使用go mod 管理项目，也不需要非得把项目放到GOPATH指定目录下，你可以在你磁盘的任何位置新建一个项目，Go1.13以后可以彻底不要GOPATH了。

实际项目开发中我们首先要在我们项目目录中用go mod命令生成一个go.mod文件管理我们项目的依赖。

比如我们的golang项目文件要放在了itying这个文件夹，这个时候我们需要在itying文件夹里面使用go mod命令生成一个go.mod文件

go mod init goProject

然后会生成一个 go.mod 的文件，里面的内容是go版本，以及以后添加的包

module goProject

go 1.14

首先我们创建一个 calc，然后里面有一个calc的文件

package calc

// 自定义包，最好和文件夹统一起来

// 公有变量
var age = 10
// 私有变量
var Name = "张三"

// 首字母大写，表示共有方法
func Add(x, y int)int  {
	return x   y
}
func Sub(x, y int)int  {
	return x - y
}

在其它地方需要引用的话，就是这样

package main
import (
	"fmt"
	"goProject/calc"
)
func main() {
	fmt.Printf("%v", calc.Add(2, 5))
}

包（package）是多个Go源码的集合，一个包可以简单理解为一个存放多个.go文件的文件夹。该文件夹下面的所有go文件都要在代码的第一行添加如下代码，声明该文件归属的包。

package 包名

注意事项

• 一个文件夹下面直接包含的文件只能归属一个package，同样一个package的文件不能在多个文件夹下。
• 包名可以不和文件夹的名字一样，包名不能包含-符号。
• 包名为main的包为应用程序的入口包，这种包编译后会得到一个可执行文件，而编译不包含main包的源代码则不会得到可执行文件。

在Go 语言程序执行时导入包语句会自动触发包内部init（）函数的调用。需要注意的是：init（） 函数没有参数也没有返回值。init（）函数在程序运行时自动被调用执行，不能在代码中主动调用它。 包初始化执行的顺序如下图所示：

包初始化执行的顺序如下图所示：

Go语言包会从main包开始检查其导入的所有包，每个包中又可能导入了其他的包。Go编译器由此构建出一个树状的包引用关系，再根据引用顺序决定编译顺序，依次编译这些包的代码。

在运行时，被最后导入的包会最先初始化并调用其init（）函数，如下图示：

也就是父类中的init先执行。

我们可以在 https://pkg.go.dev/ 查找看常见的golang第三方包

例如，前面找到前面我们需要下载的第三方包的地址

https://github.com/shopspring/decimal

然后安装这个包

go get github.com/shopspring/decimal

go mod download

依赖包会自动下载到 $GOPATH/pkg/mod目录，并且多个项目可以共享缓存的mod，注意使用go mod download的时候，需要首先在你的项目中引入第三方包

go mod vendor

将依赖复制到当前项目的vendor下

注意：使用go mod vendor的时候，首先需要在你的项目里面引入第三方包

• go download：下载依赖的module到本地cache
• go edit：编辑go.mod文件
• go graph：打印模块依赖图
• go init：在当前文件夹下初始化一个新的module，创建go.mod文件
• tidy：增加丢失的module，去掉未使用的module
• vendor：将依赖复制到vendor下
• verify：校验依赖，检查下载的第三方库有没有本地修改，如果有修改，则会返回非0，否则校验成功

首先我们先去官网找到这个包，https://github.com/shopspring/decimal

然后在我们的项目中引入

import (
	"fmt"
	"github.com/shopspring/decimal"
	"goProject/calc"
)
func main() {
	fmt.Printf("%v \n", calc.Add(2, 5))
	// 打印公有变量
	fmt.Println(calc.Name)

	_, err := decimal.NewFromString("136.02")
	if err != nil {
		panic(err)
	}
}

引入后，我们运行项目，就会去下载了，下载完成后，我们到 go.mod文件夹，能够看到依赖被引入了

module goProject

go 1.14

require github.com/shopspring/decimal v1.2.0 // indirect

同时还生成了一个 go.sum文件

github.com/shopspring/decimal v1.2.0 h1:abSATXmQEYyShuxI4/vyW3tV1MrKAJzCZ/0zLUXYbsQ=
github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql MJL6WCR6knT2jwCFRcu2hWCYk4o=

这样我们就可以使用第三包开始具体的使用了~，我们实现一个Float类型的加法

package main

import (
	"fmt"
	"github.com/shopspring/decimal"
)

func main() {
	var num1 float64 = 3.1
	var num2 float64 = 4.2
	d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(num2))
	fmt.Println(d1)
}

首先我们需要去 依赖官网，类似于我们的 maven repository

然后我们搜索gJson的包，这个包主要是用于json相关的操作

我们进去后，找到它的https://github.com/tidwall/gjson，然后提供了完整的教程

# 下载依赖
go get -u github.com/tidwall/gjson

使用

package main

import "github.com/tidwall/gjson"

const json = `{"name":{"first":"Janet","last":"Prichard"},"age":47}`

func main() {
	value := gjson.Get(json, "name.last")
	println(value.String())
}

现实生活中手机、相机、U盘都可以和电脑的USB接口建立连接。我们不需要关注usb卡槽大小是否一样，因为所有的USB接口都是按照统一的标准来设计的。

Golang中的接口是一种抽象数据类型，Golang中接口定义了对象的行为规范，只定义规范不实现。接口中定义的规范由具体的对象来实现。

通俗的讲接口就一个标准，它是对一个对象的行为和规范进行约定，约定实现接口的对象必须得按照接口的规范。

在Golang中接口（interface）是一种类型，一种抽象的类型。接口（interface）是一组函数method的集合，Golang中的接口不能包含任何变量。

在Golang中接口中的所有方法都没有方法体，接口定义了一个对象的行为规范，只定义规范不实现。接口体现了程序设计的多态和高内聚低耦合的思想N Golang中的接口也是一种数据类型，不需要显示实现。只需要一个变量含有接口类型中的所有方法，那么这个变量就实现了这个接口。

Golang中每个接口由数个方法组成，接口的定义格式如下：

type 接口名 interface {
    方法名1 (参数列表1) 返回值列表1
    方法名2 (参数列表2) 返回值列表2
}

其中

• 接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等，接口名最好突出该接口的类型含义。
• 方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
• 参数列表、返回值列表：参数列表和返回值列表中的参数变量名是可以省略

演示：定义一个Usber接口让Phone 和 Camera结构体实现这个接口

首先我们定义一个Usber接口，接口里面就定义了两个方法

// 定义一个Usber接口
type Usber interface {
	start()
	stop()
}

然后我们在创建一个手机结构体

// 如果接口里面有方法的话，必须要通过结构体或自定义类型实现这个接口

// 使用结构体来实现 接口
type Phone struct {
	Name string
}
// 手机要实现Usber接口的话，必须实现usb接口的所有方法
func (p Phone) Start()  {
	fmt.Println(p.Name, "启动")
}
func (p Phone) Stop()  {
	fmt.Println(p.Name, "关闭")
}

然后我们在创建一个Phone的结构体，来实现这个接口

// 如果接口里面有方法的话，必须要通过结构体或自定义类型实现这个接口

// 使用结构体来实现 接口
type Phone struct {
	Name string
}
// 手机要实现Usber接口的话，必须实现usb接口的所有方法
func (p Phone) start()  {
	fmt.Println(p.Name, "启动")
}
func (p Phone) stop()  {
	fmt.Println(p.Name, "关闭")
}
func main() {
	var phone Usber = Phone{
		"三星手机",
	}
	phone.start()
	phone.stop()
}

我们在创建一个Camera结构体

// 使用相机结构体来实现 接口
type Camera struct {
	Name string
}
// 相机要实现Usber接口的话，必须实现usb接口的所有方法
func (p Camera) start()  {
	fmt.Println(p.Name, "启动")
}
func (p Camera) stop()  {
	fmt.Println(p.Name, "关闭")
}
func main() {
	var camera Usber = Camera{
		"佳能",
	}
	camera.start()
	camera.stop()
}

我们创建一个电脑的结构体，电脑的结构体就是用于接收两个实现了Usber的结构体，然后让其工作

// 电脑
type Computer struct {

}

// 接收一个实现了Usber接口的 结构体
func (computer Computer) Startup(usb Usber)  {
	usb.start()
}

// 关闭
func (computer Computer) Shutdown (usb Usber)  {
	usb.stop()
}

最后我们在main中调用方法

func main() {
	var camera interfaceDemo.Camera = interfaceDemo.Camera{
		"佳能",
	}
	var phone interfaceDemo.Phone = interfaceDemo.Phone{
		"苹果",
	}

	var computer interfaceDemo.Computer = interfaceDemo.Computer{}
	computer.Startup(camera)
	computer.Startup(phone)
	computer.Shutdown(camera)
	computer.Shutdown(phone)
}

运行结果如下所示：

佳能 启动
苹果 启动
佳能 关闭
苹果 关闭

Golang中的接口可以不定义任何方法，没有定义任何方法的接口就是空接口。空接口表示没有任何约束，因此任何类型变量都可以实现空接口。

空接口在实际项目中用的是非常多的，用空接口可以表示任意数据类型。

// 空接口表示没有任何约束，任意的类型都可以实现空接口
type EmptyA interface {

}

func main() {
	var a EmptyA
	var str = "你好golang"
	// 让字符串实现A接口
	a = str
	fmt.Println(a)
}

同时golang中空接口也可以直接当做类型来使用，可以表示任意类型。相当于Java中的Object类型

var a interface{}
a = 20
a = "hello"
a = true

空接口可以作为函数的参数，使用空接口可以接收任意类型的函数参数

// 空接口作为函数参数
func show(a interface{}) {
    fmt.println(a)
}

map的值实现空接口

使用空接口实现可以保存任意值的字典

// 定义一个值为空接口类型
var studentInfo = make(map[string]interface{})
studentInfo["userName"] = "张三"
studentInfo["age"] = 15
studentInfo["isWork"] = true

slice切片实现空接口

// 定义一个空接口类型的切片
var slice = make([]interface{}, 4, 4)
slice[0] = "张三"
slice[1] = 1
slice[2] = true

一个接口的值（简称接口值）是由一个具体类型和具体类型的值两部分组成的。这两部分分别称为接口的动态类型和动态值。

如果我们想要判断空接口中值的类型，那么这个时候就可以使用类型断言，其语法格式：

x.(T)

其中：

• X：表示类型为interface{}的变量
• T：表示断言x可能是的类型

该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败

// 类型断言
var a interface{}
a = "132"
value, isString := a.(string)
if isString {
    fmt.Println("是String类型, 值为：", value)
} else {
    fmt.Println("断言失败")
}

或者我们可以定义一个能传入任意类型的方法

// 定义一个方法，可以传入任意数据类型，然后根据不同类型实现不同的功能
func Print(x interface{})  {
	if _,ok := x.(string); ok {
		fmt.Println("传入参数是string类型")
	} else if _, ok := x.(int); ok {
		fmt.Println("传入参数是int类型")
	} else {
		fmt.Println("传入其它类型")
	}
}

上面的示例代码中，如果要断言多次，那么就需要写很多if，这个时候我们可以使用switch语句来实现：

注意： 类型.(type) 只能结合switch语句使用

func Print2(x interface{})  {
	switch x.(type) {
	case int:
		fmt.Println("int类型")
	case string:
		fmt.Println("string类型")
	case bool:
		fmt.Println("bool类型")
	default:
		fmt.Println("其它类型")
	}
}

值接收者

如果结构体中的方法是值接收者，那么实例化后的结构体值类型和结构体指针类型都可以赋值给接口变量

实现多个接口的话，可能就同时用两个接口进行结构体的接受

// 定义一个Animal的接口，Animal中定义了两个方法，分别是setName 和 getName，分别让DOg结构体和Cat结构体实现
type Animal interface {
	SetName(string)
}

// 接口2
type Animal2 interface {
	GetName()string
}

type Dog struct {
	Name string
}

func (d *Dog) SetName(name string)  {
	d.Name = name
}
func (d Dog)GetName()string {
	return d.Name
}

func main() {
	var dog = &Dog{
		"小黑",
	}
	// 同时实现两个接口
	var d1 Animal = dog
	var d2 Animal2 = dog
	d1.SetName("小鸡")
	fmt.Println(d2.GetName())
}

在golang中，允许接口嵌套接口，我们首先创建一个 Animal1 和 Animal2 接口，然后使用Animal接受刚刚的两个接口，实现接口的嵌套。

// 定义一个Animal的接口，Animal中定义了两个方法，分别是setName 和 getName，分别让DOg结构体和Cat结构体实现
type Animal1 interface {
	SetName(string)
}

// 接口2
type Animal2 interface {
	GetName()string
}

type Animal interface {
	Animal1
	Animal2
}

type Dog struct {
	Name string
}

func (d *Dog) SetName(name string)  {
	d.Name = name
}
func (d Dog)GetName()string {
	return d.Name
}

func main() {
	var dog = &Dog{
		"小黑",
	}
	// 同时实现两个接口
	var d Animal = dog
	d.SetName("小鸡")
	fmt.Println(d.GetName())
}

// golang中空接口和类型断言
var userInfo = make(map[string]interface{})
userInfo["userName"] = "zhangsan"
userInfo["age"] = 10
userInfo["hobby"] = []string{"吃饭", "睡觉"}
fmt.Println(userInfo["userName"])
fmt.Println(userInfo["age"])
fmt.Println(userInfo["hobby"])
// 但是我们空接口如何获取数组中的值？发现 userInfo["hobby"][0]  这样做不行
// fmt.Println(userInfo["hobby"][0])

也就是我们的空接口，无法直接通过索引获取数组中的内容，因此这个时候就需要使用类型断言了

// 这个时候我们就可以使用类型断言了
hobbyValue,ok := userInfo["hobby"].([]string)
if ok {
    fmt.Println(hobbyValue[0])
}

通过类型断言返回来的值，我们就能够直接通过角标获取了。

golang中的主线程：（可以理解为线程/也可以理解为进程），在一个Golang程序的主线程上可以起多个协程。Golang中多协程可以实现并行或者并发。

协程：可以理解为用户级线程，这是对内核透明的，也就是系统并不知道有协程的存在，是完全由用户自己的程序进行调度的。Golang的一大特色就是从语言层面原生持协程，在函数或者方法前面加go关键字就可创建一个协程。可以说Golang中的协程就是goroutine。

Golang中的多协程有点类似于Java中的多线程。

多协程和多线程

多协程和多线程：Golang中每个goroutine（协程）默认占用内存远比Java、C的线程少。

OS线程（操作系统线程）一般都有固定的栈内存（通常为2MB左右），一个goroutine（协程）占用内存非常小，只有2KB左右，多协程goroutine切换调度开销方面远比线程要少。

这也是为什么越来越多的大公司使用Golang的原因之一。

在主线程（可以理解成进程）中，开启一个goroutine，该协程每隔50毫秒秒输出“你好golang"

在主线程中也每隔50毫秒输出“你好golang"，输出10次后，退出程序，要求主线程和goroutine同时执行。

这是时候，我们就可以开启协程来了，通过 go关键字开启

// 协程需要运行的方法
func test()  {
	for i := 0; i < 5; i   {
		fmt.Println("test 你好golang")
		time.Sleep(time.Millisecond * 100)
	}
}
func main() {

	// 通过go关键字，就可以直接开启一个协程
	go test()

	// 这是主进程执行的
	for i := 0; i < 5; i   {
		fmt.Println("main 你好golang")
		time.Sleep(time.Millisecond * 100)
	}
}

运行结果如下，我们能够看到他们之间不存在所谓的顺序关系了

main 你好golang
test 你好golang
main 你好golang
test 你好golang
test 你好golang
main 你好golang
main 你好golang
test 你好golang
test 你好golang
main 你好golang

但是上述的代码其实还有问题的，也就是说当主进程执行完毕后，不管协程有没有执行完成，都会退出

这是使用我们就需要用到 sync.WaitGroup等待协程

首先我们需要创建一个协程计数器

// 定义一个协程计数器
var wg sync.WaitGroup

然后当我们开启协程的时候，我们要让计数器加1

// 开启协程，协程计数器加1
wg.Add(1)
go test2()

当我们协程结束前，我们需要让计数器减1

// 协程计数器减1
wg.Done()

完整代码如下