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 类型。
