1、OOP

首先，Go 语言并不是面向对象的语言，只是可以通过一些方法来模拟面向对象。

1.1、封装

Go 语言是通过结构体（struct）来实现封装的。

1.2、继承

继承主要由下面这三种方式实现：

1.2.1、嵌套匿名字段

//Address 地址结构体
type Address struct {Province stringCity     string
}//User 用户结构体
type User struct {Name    stringGender  stringAddress //匿名字段
}func main() {var user2 Useruser2.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 stringCity     string
}//User 用户结构体
type User struct {Name    stringGender  stringAddress 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 mainimport "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.gotype 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 {ReaderWriter
}// ReadCloser 是组合Reader接口和Closer接口形成的新接口类型
type ReadCloser interface {ReaderCloser
}// WriteCloser 是组合Writer接口和Closer接口形成的新接口类型
type WriteCloser interface {WriterCloser
}

同时，接口也可以作为结构体的字段，就像 Java 中 Map 可以作为对象属性一样：

// src/sort/sort.go// Interface 定义通过索引对元素排序的接口类型
type Interface interface {Len() intLess(i, j int) boolSwap(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 类型。