Golang中的面向对象特性

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
首先hellokitty 是猫咪，它可以完成猫咪的所有事情，另外，它还是粉红色的.

多态

多态是面向对象的基石。 多态就是不同的对象可以执行相同的动作，但要通过自己的代码来执行.
多态的原理是方法被调用时，只有继承链最末端的方法会被调用 --引用自 [.NET 框架设计] 作者: Jeffrey Richter

在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的相关实现。