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

多态

多态是面向对象的基石。 多态就是不同的对象可以执行相同的动作,但要通过自己的代码来执行.
多态的原理是方法被调用时,只有继承链最末端的方法会被调用 --

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