1、OOP
首先，Go 语言并不是面向对象的语言，只是可以通过一些方法来模拟面向对象。
1.1、封装
Go 语言是通过结构体（struct）来实现封装的。
1.2、继承
继承主要由下面这三种方式实现：
1.2.1、嵌套匿名字段
//Address 地址结构体
type Address struct {
Province string
City string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address //匿名字段
}
func main() {
var user2 User
user2.Name = "小王子"
user2.Gender = "男"
user2.Address.Province = "山东" // 匿名字段默认使用类型名作为字段名
user2.City = "威海" // 匿名字段可以省略
fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}}
}
1.2.2、嵌套结构体
//Address 地址结构体
type Address struct {
Province string
City string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address Address
}
func main() {
user1 := User{
Name: "小王子",
Gender: "男",
Address: Address{
Province: "山东",
City: "威海",
},
}
fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}}
}
1.2.3、嵌套匿名结构体指针
//Animal 动物
type Animal struct {
name string
}
func (a *Animal) move() {
fmt.Printf("%s会动！\n", a.name)
}
//Dog 狗
type Dog struct {
Feet int8
*Animal //通过嵌套匿名结构体实现继承
}
func (d *Dog) wang() {
fmt.Printf("%s会汪汪汪~\n", d.name)
}
func main() {
d1 := &Dog{
Feet: 4,
Animal: &Animal{ //注意嵌套的是结构体指针
name: "乐乐",
},
}
d1.wang() //乐乐会汪汪汪~
d1.move() //乐乐会动！
}
而既然结构体可以继承，那么结构体就必须有方法，Go 语言的方法必须在方法名前面声明调用者。子类可以重写父类方法：如果在子结构体（或任何类型）上定义了一个与父结构体中同名的方法，那么这个方法就会覆盖父结构体中的方法。这就实现了重写。
1.3、多态
多态：一个事物拥有多种形态就是多态！
有多态就必须要有接口，因为接口就是为了解决多态这个问题的：
1.3.1、接口
- Go 语言提供了接口数据类型
- 接口就是把一些共性的方法放在一起定义
- Go 语言中的接口是隐式声明的（相比较 Java 会用 implements 关键字显示声明）
- 只有实现类把接口的方法全部实现才算实现了这个接口
接口的实现类都拥有多态的特性，因为它除了是自己还是它的接口类型。
package main
import "fmt"
// 接口
type USB interface {
input()
output()
}
// 结构体
type Mouse struct {
name string
}
// 实现接口:实现了接口的所有方法才算实现了这个接口
func (mouse Mouse) input(){
fmt.Println(mouse.name,"鼠标输入")
}
func (mouse Mouse) output(){
fmt.Println(mouse.name,"鼠标输出")
}
type KeyBoard struct {
name string
}
func (keyBoard KeyBoard) input(){
fmt.Println(keyBoard.name,"键盘输入")
}
func (keyBoard KeyBoard) output(){
fmt.Println(keyBoard.name,"键盘输出")
}
func test(u USB) {
u.input()
u.output()
}
func main() {
mouse := Mouse{name: "罗技"}
test(mouse)
keyBoard := KeyBoard{name: "艾石头"}
test(keyBoard)
// 通过接口创建子类实例
var usb USB = Mouse{name: "外星人"}
usb.input()
// 但是接口是无法使用实现类的属性的
}运行结果：
罗技 鼠标输入
罗技 鼠标输出
艾石头 键盘输入
艾石头 键盘输出
外星人 鼠标输入1.3.2、空接口
空接口不包含任何方法，所以所有的结构体都默认实现了空接口（类似于 Java 的 Object）！
所谓的空接口，就是：
type 接口名称 interface{}go 语言中的 any 其实就是空接口，我们可以在源码中看到：
如果我们定义一个方法或者函数它可以传入一个空接口类型，那么就相当于任何类型都可以传入这个方法或函数，因为任何结构体类型的都实现了空接口。比如我们 go 语言中的打印方法的参数就都是 any ... 。
2、接口
上面只是描述了接口是怎么实现多态的，但是对接口的用法并没有深入介绍，这里我们详细介绍接口的用法。
2.1、接口的定义
type 接口名 interface{
方法名1(参数列表) (返回值列表)
方法名2(参数列表) (返回值列表)
// ...
}需要注意的是：
- 接口类型名：Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有关闭操作的接口叫closer等。接口名最好要能突出该接口的类型含义。
- 方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
- 参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。
2.2、接口类型变量
所谓的接口类型变量就就像 Java 中的：
Map<String,Integer> map;
HashMap<String,Integer> map1 = new HashMap<>();
TreeMap<String,Integer> map2 = new TreeMap<>();
map = m1;
map = m2;这里的变量 map 就是一个接口变量，接口变量可以通过任何实现类来赋值。
2.3、接口的嵌套
Go 语言中的接口可以组合嵌套，这是区别于 Java 很大的一点。在 Go标准库 io 源码中就有很多接口之间互相组合的示例：
// src/io/io.go
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
type Closer interface {
Close() error
}
// ReadWriter 是组合Reader接口和Writer接口形成的新接口类型
type ReadWriter interface {
Reader
Writer
}
// ReadCloser 是组合Reader接口和Closer接口形成的新接口类型
type ReadCloser interface {
Reader
Closer
}
// WriteCloser 是组合Writer接口和Closer接口形成的新接口类型
type WriteCloser interface {
Writer
Closer
}
同时，接口也可以作为结构体的字段，就像 Java 中 Map 可以作为对象属性一样：
// src/sort/sort.go
// Interface 定义通过索引对元素排序的接口类型
type Interface interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
// reverse 结构体中嵌入了Interface接口
type reverse struct {
Interface
}
2.4、类型断言
类型断言就像 Java 中的强转一样，一般是把一个抽象的接口类型转为一个确定的实现类型。好像说我们可以"断言"这个接口类型一定是这个实现类类型。
2.4.1、语法
x.(T)- x：表示接口类型的变量（如果不是接口类型的就在前面加上空接口）
- T：表示断言 x 是 T 类型
注意：类型断言的返回结果是两个参数，第一个返回值是一个转为断言类型后的变量，第二个返回值是转为断言的结果（布尔类型，代表成功/失败）
对于数值类型（ 比如 int、string、float64... ）这些不是接口类型的数据，如果要做类型断言就需要给它前面加个空接口，因为所有类型都是隐式地实现了空接口的。
str := "10"
// 第2个返回值是断言结果
res,_ := interface{}(str).(int)
fmt.Println(res) // 10对于接口类型变量，如果我们能知道它是哪个实现类型就可以直接进行类型断言：
var usb USB = Mouse{name: "外星人"}
// 类型断言 这里没有接收第二个返回值，代表丢弃
m := usb.(Mouse)
fmt.Println(m)上面的 USB 是接口类型，而它的地址指向一个 Mouse 类型的实例，所以我们可以断言这个 USB 实例一定是 Mouse 类型。
