Go语言面向对象编程实践：封装、继承与重写

引言

Go语言虽然不完全是面向对象的编程语言，但它通过结构体(struct)、方法(methods)和接口(interfaces)等特性，提供了实现面向对象编程范式的能力。本文将结合具体代码示例，详细解析Go语言中的封装、继承和重写三大面向对象特性。

一、封装：结构体与方法

1.1 结构体定义

Go语言使用结构体来封装数据，类似于其他语言中的类。在以下示例中，我们定义了两种几何图形：

type Rectangle struct {
    width, height float64
}

type Circle struct {
    radius float64
}

这里Rectangle结构体封装了矩形的宽和高，Circle结构体封装了圆的半径。

1.2 方法定义

Go语言的方法是与特定类型关联的函数，通过接收者(receiver)参数实现：

func (r Rectangle) area() float64 {
    return r.width * r.height
}

func (c Circle) area() float64 {
    return c.radius * c.radius * math.Pi
}

(r Rectangle)和(c Circle)是方法接收者，指定了方法所属的类型
方法可以访问接收者的所有字段
每个结构体可以有自己的方法实现

1.3 使用示例

func main() {
    r1 := Rectangle{12, 2}
    r2 := Rectangle{9, 4}
    c1 := Circle{10}
    c2 := Circle{25}
    
    fmt.Println("Area of r1 is: ", r1.area())
    fmt.Println("Area of r2 is: ", r2.area())
    fmt.Println("Area of c1 is: ", c1.area())
    fmt.Println("Area of c2 is: ", c2.area())
}

输出结果：

Area of r1 is:  24
Area of r2 is:  36
Area of c1 is:  314.1592653589793
Area of c2 is:  1963.4954084936207

二、继承：匿名字段与组合

2.1 匿名字段实现继承

Go语言通过结构体嵌套（匿名字段）实现类似继承的功能：

type Human struct {
    name  string
    age   int
    phone string
}

type Student struct {
    Human  // 匿名字段，实现继承
    school string
}

type Employee struct {
    Human   // 匿名字段，实现继承
    company string
}

Human是基类（父类）
Student和Employee通过嵌入Human匿名字段继承其字段和方法
这种方式称为”组合”，是Go语言推崇的代码复用方式

2.2 基类方法

1
2
3

func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

2.3 继承的使用

func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
    
    mark.SayHi()  // Student继承了Human的SayHi方法
    sam.SayHi()   // Employee继承了Human的SayHi方法
}

输出结果：

1 2	Hi, I am Mark you can call me on 222-222-YYYY Hi, I am Sam you can call me on 111-888-XXXX

三、重写：方法覆盖

3.1 方法重写机制

Go语言允许子类型定义同名方法来覆盖（重写）父类型的方法：

// Human定义method
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

// Employee的method重写Human的method
func (e *Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", 
        e.name, e.company, e.phone)
}

3.2 重写的效果

func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
    
    mark.SayHi()  // 调用继承的Human方法
    sam.SayHi()   // 调用重写的Employee方法
}

输出结果：

1 2	Hi, I am Mark you can call me on 222-222-YYYY Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX

3.3 重写特点

自动选择：Go编译器根据接收者的实际类型自动选择调用哪个方法
就近原则：优先调用接收者自身定义的方法
显式访问：如果需要访问父类方法，可以通过e.Human.SayHi()显式调用

四、Go语言面向对象的特色

4.1 与传统的面向对象语言的对比

特性	Go语言实现	传统OOP语言
类	结构体(struct)	class
对象	结构体实例	object
继承	结构体组合	extends
多态	接口(interface)	抽象类/接口
封装	包级别控制	public/private/protected