Golang 作为新世纪的C语言，有着与C接近的高性能，有着比C更为简洁的表达，有着无与伦比的海量并发支持。作为一门现代语言，Golang 吸取了很多语言特性，比如：Golang吸取了函数式编程的特性:匿名函数和闭包; 面向对象语言特性的支持; 高级语言中的垃圾回收和反射机制的支持等。
那么，我们来了解一下Golang对面向对象的一些特性支持。
面向对象思想最重要的三个特性，封装，继承，多态，在golang语言中也有体现，我们来讨论一下
封装
一个对象或实体包含它能进行操作所需要的所有信息，这个特性称为封装，因此它就可以不必依赖其他对象来完成自己的操作.
封装的好处：
- 良好的封装减少耦合
- 实体内部可以自由修改
- 具有清晰的对外接口
Golang中我们可以使用结构来实现封装
例如, 我们在animal 包中 定义一个Cat 的 struct ，并给出初始化方法, 一个Shout 方法.
package cat
import "fmt"
type Cat struct {
name string
age uint
}
func (c *Cat) Init(name string, age uint) {
c.name = name
c.age = age
}
func (c *Cat) Shout() {
fmt.Printf("Hi, I am %s, aged %d, 喵喵喵\n", c.name, c.age)
}
在main 方法中使用如下:
package main
import animal "github.com/oop-test/animal"
func main() {
cat := animal.Cat{}
cat.Init("mimi", 1)
cat.Shout()
}
结果如下：
Hi, I am mimi, aged 1, 喵喵喵但是当我们试图重新给age赋值时候
cat.age = 2
cat.age undefined (cannot refer to unexported field or method age)那么如何解决呢？我们把age 改为大写即可.
type Cat struct {
name string
Age uint
}
func main() {
cat := animal.Cat{}
cat.Init("mimi", 1)
cat.Shout()
cat.Age = 2
cat.Shout()
}
API server listening at: 127.0.0.1:38404
Hi, I am mimi, aged 1, 喵喵喵
Hi, I am mimi, aged 2, 喵喵喵
这样做其实非常的丑陋，面向对象的一个原则是对外的时候，永远要有最低的开放度，那么直接把成员设置为公共，就失去了对成员的控制，比如，你无法控制一个人把猫咪的age设置为一亿岁，者显然不合逻辑。开放公共成员，等于任何人都会去你家洗澡，这非常的难受.
参照面向对象的原则，我们可以写一个SetAge方法来控制age 变量的逻辑.
func (c *Cat ) SetAge(age uint){
if age > 20{
log.Panic("are u kidding? cat can not live so long time")
}else{
c.age = age
}
}
调用下
func main() {
cat := animal.Cat{}
cat.Init("mimi", 1)
cat.Shout()
cat.SetAge(2)
cat.Shout()
cat.SetAge(100)
}
Hi, I am mimi, aged 1, 喵喵喵 Hi, I am mimi, aged 2, 喵喵喵 2019/03/26 20:57:47 are u kidding? cat can not live so long time panic: are u kidding? cat can not live so long time继承
继承代表了一种‘is-a’的关系. 如果A和B，那么可以描述为 B是A
继承者可以理解为是对被继承者的特殊化. 它具有被继承者的特性外，还有自己独立的个性.
Golang中没有显式的继承关系，我们可以使用组合来实现.
例如，HelloKitty，就可以继承Cat
type HelloKitty struct {
Cat
color string
}
func (h *HelloKitty) Init(name string, age uint, color string) {
h.Cat.Init(name, age)
h.color = color
}
func(h *HelloKitty) Shout(){
h.Cat.Shout()
fmt.Printf("and i'am so cute because i am %s", h.color)
}
我们来调用一下
func main() {
kitty := animal.HelloKitty{}
kitty.Init("kitty", 1, "pink")
kitty.Shout()
}
API server listening at: 127.0.0.1:9400 Hi, I am kitty, aged 1, 喵喵喵 and i'am so cute because i am pink多态
多态是面向对象的基石。 多态就是不同的对象可以执行相同的动作，但要通过自己的代码来执行.
多态的原理是方法被调用时，只有继承链最末端的方法会被调用 --
在Golang中，多态的实现非常的简洁，通过interface，我们就可以非常容易的实现多态的功能了.
那么，假设我们定义一个动物接口，那么动物都会叫, 我们就定义了一个抽象的接口
package animal
type Animal interface {
Shout()
}
猫和狗都重写了 Animal interface， 在Golang中，一个struct只要定义了接口的方法，就是实现了该接口，非常的简洁.
猫：
func (c Cat) Shout() {
fmt.Printf("Hi, I am %s, aged %d, 喵喵喵\n", c.name, c.age)
}
狗：
package animal
import "fmt"
type Dog struct {
}
func (dog Dog) Shout() {
fmt.Println("汪汪汪.")
}
那么该如何实现运行时的动态绑定呢？
func main() {
var animal a.Animal
animal = a.Dog{}
animal.Shout()
animal = a.Cat{}
animal.Shout()
}
执行：
API server listening at: 127.0.0.1:47116 汪汪汪. Hi, I am , aged 0, 喵喵喵可以看到，通过定义抽象的接口，以及实现接口方法的具体类型的方式，Golang实现了运行时的动态绑定，这就是所谓的抽象与多态。
总结
通过以上例子，我们了解了Golang中OOP的相关实现。