基础学习 - 封装继承多态 - 《Golang 学习笔记》

封装
继承
多态
总结

让我们回忆一下面向对象的三大基本特征：

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式
继承：使得子类具有父类的属性和方法或者重新定义、追加属性和方法等
多态：不同对象中同种行为的不同实现方式

我们一起来看看 Go 语言是如何在没有类（Class）的情况下实现这三大特征的。

封装

「类」

在 Go 语言中可以使用结构体（Structs）对属性进行封装，结构体就像是类的一种简化形式。

例如，我们要定义一个矩形，每个矩形都有长和宽，我们可以这样进行封装：

type Rectangle struct {
    Length int
    Width int
}

方法

既然有了「类」，你可能会问了，那「类」的方法在哪呢？

Go 语言中也有方法（Methods）：Go 方法是作用在接收者（receiver）上的一个函数，接收者是某种类型的变量。因此方法是一种特殊类型的函数。

定义方法的格式如下：

func (recv receiver_type) methodName(parameter_list) (return_value_list) { ... }

上文中我们已经定义了一个矩形 Rectangle，现在我们要定义一个方法 Area() 来计算它的面积：

package main
import (
    "fmt"
)
// 矩形结构体
type Rectangle struct {
    Length int
    Width  int
}
// 计算矩形面积
func (r *Rectangle) Area() int {
    return r.Length * r.Width
}
func main() {
    r := Rectangle{4, 2}
    // 调用 Area() 方法，计算面积
    fmt.Println(r.Area())
}

上面的代码片段输出结果为 8。

访问权限

我们常会说一个类的属性是公共的还是私有的，在其他编程语言中，我们常用 public 与 private 关键字来表达这样一种访问权限。

在 Go 语言中没有 public、private、protected 这样的访问控制修饰符，它是通过字母大小写来控制可见性的。

如果定义的常量、变量、类型、接口、结构、函数等的名称是大写字母开头，这表示它们能被其它包访问或调用（相当于 public）；非大写开头就只能在包内使用（相当于 private）。

访问未导出字段

当遇到只能在包内使用的未导出字段时，我们又该如何访问呢？

和其他面向对象语言一样，Go 语言也有实现 getter 和 setter 的方式：

对于 setter 方法使用 Set 前缀
对于 getter 方法只使用成员名

例如我们现在有一个处于 person 包中的 Person 结构体：

package person
type Person struct {
    firstName string
    lastName  string
}

我们可以看到，它的两个成员变量都是非大写字母开头，只能在包内使用，现在我们为其中的 firstName 来定义 setter 与 getter ：

// 获取 firstName
func (p *Person) FirstName() string {
    return p.firstName
}
// 设置 firstName
func (p *Person) SetFirstName(newName string) {
    p.firstName = newName
}

这样一来，我们就可以在 main 包里设置和获取 firstName 的值了：

package main
import (
    "fmt"
    "./person"
)
func main() {
    p := new(person.Person)
    p.SetFirstName("firstName")
    fmt.Println(p.FirstName())
}
/* Output:
firstName
*/

继承

在 Go 语言中没有 extends 关键字，它使用在结构体中内嵌匿名类型的方法来实现继承。

匿名类型：即这些类型没有显式的名字。

我们定义一个 Engine 接口类型，一个 Car 结构体，让 Car 结构体包含一个 Engine 类型的匿名字段：

type Engine interface {
    Start()
    Stop()
}
type Car struct {
    Engine // 包含 Engine 类型的匿名字段
}

此时，匿名字段 Engine 上的方法「晋升」成为了外层类型 Car 的方法。我们可以构建出如下代码：

func (c *Car) GoToWorkIn() {
    // get in car
    c.Start()
    // drive to work
    c.Stop()
    // get out of car
}

多态

在面向对象中，多态的特征为：不同对象中同种行为的不同实现方式。在 Go 语言中可以使用接口实现这一特征。

我们先定义一个正方形 Square 和一个长方形 Rectangle：

// 正方形
type Square struct {
    side float32
}
// 长方形
type Rectangle struct {
    length, width float32
}

然后，我们希望可以计算出这两个几何图形的面积。但由于他们的面积计算方式不同，我们需要定义两个不同的 Area() 方法。

于是，我们可以定义一个包含 Area() 方法的接口 Shaper，让 Square 和 Rectangle 都实现这个接口里的 Area()：

// 接口 Shaper
type Shaper interface {
    Area() float32
}
// 计算正方形的面积
func (sq *Square) Area() float32 {
    return sq.side * sq.side
}
// 计算长方形的面积
func (r *Rectangle) Area() float32 {
    return r.length * r.width
}

我们可以在 main() 函数中这样调用 Area()：

func main() {
    r := &Rectangle{10, 2}
    q := &Square{10}
    // 创建一个 Shaper 类型的数组
    shapes := []Shaper{r, q}
    // 迭代数组上的每一个元素并调用 Area() 方法
    for n, _ := range shapes {
        fmt.Println("图形数据: ", shapes[n])
        fmt.Println("它的面积是: ", shapes[n].Area())
    }
}
/*Output:
图形数据:  &{10 2}
它的面积是:  20
图形数据:  &{10}
它的面积是:  100
*/

由以上代码输出结果可知：不同对象调用 **Area()** 方法产生了不同的结果，展现了多态的特征。

总结

面向对象的三大特征是：封装、继承和多态
Go 语言使用结构体对属性进行封装，结构体就像是类的一种简化形式
在 Go 语言中，方法是作用在
接收者（receiver）上的一个函数，接收者是某种类型的变量
名称首字母的大小写决定了该变量/常量/类型/接口/结构/函数……能否被外部包导入
无法被导入的字段可以使用 getter 和 setter 的方式来访问
Go 语言使用在结构体中内嵌匿名类型的方法来实现继承
使用接口可以实现多态