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