转载-golang面向对象分析

Posted 2020-10-10

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了转载-golang面向对象分析相关的知识，希望对你有一定的参考价值。

原文链接

这篇文章写的真心是好, 把Golang的OOP诠释的很清楚.

本imi增加了, 自己的理解.

struct有内嵌(组合), 有重写, 但是没有重载; interface具有多态性.

说道面向对象(OOP)编程, 就不得不提到下面几个概念:
- 抽象
- 封装
- 继承(重写, 重载)
- 多态

其实有个问题Is Go An Object Oriented Language?, 随便谷歌了一下, 你就发现讨论这个的文章有很多:
1. reddit
2. google group

那么问题来了

Golang是OOP吗?
使用Golang如何实现OOP?

我入门教程基本就是A Tour Of Go以及Go Web 编程. 由于之前是写C++, 但是说到Go面向对象编程, 总是感觉怪怪的, 总感觉缺少点什么. 我搜集了一些资料和例子, 加上我的一些理解, 整理出这样一篇文章.

一. 抽象和封装

抽象和封装就放在一块说了. 这个其实挺简单. 看一个例子就行了.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type rect struct {
    width int
    height int
}
 
func (r *rect) area() int {
    return r.width * r.height
}
 
func main() {
    r := rect{width: 10, height: 5}
    fmt.Println("area: ", r.area())
}
 

完整代码

要说明的几个地方:
1、Golang中的struct和其他语言的class是一样的.

2、可见性. 这个遵循Go语法的大小写的特性

3、上面例子中, 称*rect为receiver. 关于receiver 可以有两种方式的写法:

1
2
3
4
func (r *rect) area() int {
    return r.width * r.height
}
 

1
2
3
4
func (r rect) area() int {
    return r.width * r.height
}
 

这其中有什么区别和联系呢? 关于详细解释请查看astaxie的解释, 写的非常清晰.

简单来说, Receiver可以是值传递, 还是可以是指针, 两者的差别在于, 指针作为Receiver会对实例对象的内容发生操作,而普通类型作为Receiver仅仅是以副本作为操作对象,并不对原实例对象发生操作。

4、当Receiver为*rect指针的时候, 使用的是r.width, 而不是(*r).width, 是由于Go自动帮我转了,两种方式都是正确的.

5、任何类型都可以声明成新的类型, 因为任何类型都可以有方法.

1
2
3
4
5
type Interger int
func (i Interger) Add(interger Interger) Interger {
    return i + interger
}
 

6、虽然Interger是从int声明而来, 但是这样用是错误的.

1
2
3
var i Interger = 1
var a int = b //cannot use i (type Interger) as type int in assignment 
 

这是因为Go中没有隐式转换(写C++的同学都会特别讨厌这个, 因为编译器背着我们干的事情太多了). Golang中类型之间的相互赋值都必须显式声明.

上面的例子改成下面的方式就可以了.

1
2
3
var i Interger = 1
var a int = int(b)
 

二. 继承(Composition)

说道继承，其实在Golang中是没有继承(Extend)这个概念. 因为Golang舍弃掉了像C++, Java的这种传统的、类型驱动的子类。

Go Effictive says:
Go does not provide the typical, type-driven notion of subclassing, but it does have the ability to “borrow” pieces of an implementation by embedding types within a struct or interface.

换句话说, Golang中没有继承, 只有Composition.

Golang中的Compostion有两种形式, 匿名组合(Pseudo is-a)和非匿名组合(has-a)

注: 如果不了解OOP的is-a和has-a关系的话, 请自行google.

1. has-a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main
 
import (
    "fmt"
)
 
type Human struct {
    name  string
    age   int
    phone string
}
 
type Student struct {
    h      Human //非匿名字段
    school string
}
 
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
func (s *Student) SayHi() {
    fmt.Printf("Hi student, I am %s you can call me on %s", s.h.name, s.h.phone)
}
 
func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    fmt.Println(mark.h.name, mark.h.age, mark.h.phone, mark.school)
    mark.h.SayHi()
    mark.SayHi()
 
}
 

Output
Mark 25 222-222-YYYY MIT
Hi, I am Mark you can call me on 222-222-YYYY
Hi student, I am Mark you can call me on 222-222-YYYY

完整代码

这种组合方式, 其实对于了解传统OOP的话, 很好理解, 就是把一个struct作为另一个struct的字段.

从上面例子可以, Human完全作为Student的一个字段使用. 所以也就谈不上继承的相关问题了.我们也不去重点讨论.

2. is-a(Pseudo)----Embedding

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
type Human struct {
    name string
    age int
    phone string
}
 
type Student struct {
    Human //匿名字段
    school string
}
 
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    fmt.Println(mark.name, mark.age, mark.phone, mark.school)
    mark.SayHi()
}
 

Output
Mark 25 222-222-YYYY MIT
Hi, I am Mark you can call me on 222-222-YYYY

完整代码

这里要说的有几点:

1、字段
现在Student访问Human的字符, 就可以直接访问了, 感觉就是在访问自己的属性一样. 这样就实现了OOP的继承.

1
2
fmt.Println("Student age:", mark.age) //输出: Student age: 25
 

但是, 我们也可以间接访问:

1
2
fmt.Println("Student age:", mark.Human.age) //输出: Student age: 25
 

这有个问题, 如果在Student也有个字段name, 那么当使用mark.name会以Student的name为准.

1
2
fmt.Println("Student name:", mark.name) //输出:Student Name: student name
 

完整代码

2、方法
Student也继承了Human的SayHi()方法

1
2
mark.SayHi() // 输出: Hi, I am Mark you can call me on 222-222-YYYY
 

当然, 我们也可以重写SayHi()方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
type Human struct {
    name  string
    age   int
    phone string
}
 
type Student struct {
    Human  //匿名字段
    school string
    name   string
}
 
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
func (h *Student) SayHi() {
    fmt.Println("Student Sayhi")
}
 
func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT", "student name"}   
    mark.SayHi()
}
 

Output
Student Sayhi

完整代码

3、为什么称其为Pseudo is-a呢?

因为匿名组合不提供多态的特性. 如下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
 
type A struct{
}
 
type B struct {
    A  //B is-a A
}
 
func save(A) {
    //do something
}
 
func main() {
    b := new(B)
    save(*b);  
}
 

Output
cannot use *b (type B) as type A in argument to save

完整代码

还有一个面试题的例子(说明go的匿名组合只有重写, 没有重载)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
type People struct{}
 
func (p *People) ShowA() {
    fmt.Println("showA")
    p.ShowB()
}
func (p *People) ShowB() {
    fmt.Println("showB")
}
 
type Teacher struct {
    People
}
 
func (t *Teacher) ShowB() {
    fmt.Println("teacher showB")
}
 
func main() {
    t := Teacher{}
    t.ShowA()
}
 

输出结果是什么呢?

Output
ShowA
ShowB

Effective Go Says:

There‘s an important way in which embedding differs from subclassing. When we embed a type, the methods of that type become methods of the outer type, but when they are invoked the receiver of the method is the inner type, not the outer one

也就是说, Teacher由于组合了People, 所以Teacher也有了ShowA()方法, 但是在ShowA()方法里执行到ShowB时, 这个时候的receiver是*People而不是*Teacher, 主要原因还是因为embedding是一个Pseudo is-a, 没有多态的功能.

4、 "多继承"的问题(go没有多重继承, 必须显示引用)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main
 
import "fmt"
 
type School struct {
    address string
}
 
func (s *School) Address() {
    fmt.Println("School Address:", s.address)
}
 
type Home struct {
    address string
}
 
func (h *Home) Address() {
    fmt.Println("Home Address:", h.address)
}
 
type Student struct {
    School
    Home
    name string
}
 
func main() {
    mark := Student{School{"aaa"}, Home{"bbbb"}, "cccc"}
    fmt.Println(mark)
    mark.Address()
    fmt.Println(mark.address)
 
    mark.Home.Address()
    fmt.Println(mark.Home.address)
}
 

输出结果:
30: ambiguous selector mark.Address
31: ambiguous selector mark.address

完整代码

由此可以看出, Golang中不管是方法还是属性都不存在类似C++那样的多继承的问题. 要访问Embedding相关的属性和方法, 需要在加那个相应的匿名字段, 如:

1
2
mark.Home.Address()
 

5、Embedding value和 Embedding pointer的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main
 
import (
    "fmt"
)
 
type Person struct {
    name string
}
 
type Student struct {
    *Person
    age int
}
 
type Teacher struct {
    Person
    age int
}
 
func main()  {
    s := Student{&Person{"student"}, 10}
    t := Teacher{Person{"teacher"}, 40}
    fmt.Println(s, s.name)
    fmt.Println(t, t.name)
}
 

Output
{0x1040c108 10} student
{{teacher} 40} teacher

完整代码

I. 两者对于结果来说, 没有啥区别, 只是对传参的时候有影响
II. Embedding value是比较常规的写法
III. Embedding pointer比较有优势一点, 不需要关注指针是什么时间被初始化的.

三. Interface

Golang中Composite不提供多态的功能, 那是否Golang不提供多态呢? 答案肯定是否定. Golang依靠Interface实现多态的功能.

下面是我工程里面一段代码的简化:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main
 
import (
    "fmt"
)
 
type Check interface {
    CheckOss()
}
 
type CheckAudio struct {
    //something
}
 
func (c *CheckAudio) CheckOss() {
    fmt.Println("CheckAudio do CheckOss")
}
 
func main() {
    checkAudio := CheckAudio{}
 
    var i Check
 
    i = &checkAudio //想一下这里为啥需要&, 这一点是很多书里面提到的, 
                    //即指针才具有指针的方法
                    //而反过来是不成立的, 非指针不会具有指针的方法
    i.CheckOss()
}
 
 

完整代码

1、Interface 如何Composite ?

1
2
3
4
5
6
7
8
9
10
11
12
13
type Reader interface {
    Read(p []byte) (n int, err error)
}
 
type Writer interface {
    Write(p []byte) (n int, err error)
}
 
type ReadWriter interface {
    Reader
    Writer
}
 

其实很简单, 就是把Reader, Writer嵌入到ReadWriter中, 这样ReadWriter就拥有了Reader和Writer的方法.

尾声

至此, 基本说完了Golang的面向对象. 有哪里我理解的不对的地方, 请给我留言.

参考资料
1. Effective Go: Embedding
2. Go面试题
3. Is Go An Object Oriented Language?
4. go web编程
5. object-oriented-programming-in-go

以上是关于转载-golang面向对象分析的主要内容，如果未能解决你的问题，请参考以下文章

VSCode自定义代码片段——JS中的面向对象编程

VSCode自定义代码片段9——JS中的面向对象编程