Golang 面向对象编程，如何实现 封装、继承、多态

于 2025-06-22 12:24:43 发布
阅读量428 收藏 4
点赞数 10
CC 4.0 BY-SA版权
分类专栏： golang 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cbaln0/article/details/148825802

Go语言虽然不是纯粹的面向对象语言，但它通过结构体(struct)、接口(interface)和方法(method)提供了面向对象编程的能力。下面我将通过具体示例展示Go中如何实现类、封装、继承、多态以及构造函数等概念。

1. 类与封装

在Go中，使用结构体(struct)来定义"类"，并通过大小写控制访问权限实现封装。 

package main

import "fmt"

// Person 类（结构体）
type Person struct {
    name string // 小写开头，私有字段（仅在当前包内可访问）
    Age  int    // 大写开头，公共字段（可在其他包中访问）
}

// NewPerson 构造函数（工厂函数）
// 通常以New开头命名构造函数
func NewPerson(name string, age int) *Person {
    return &Person{
        name: name,
        Age:  age,
    }
}

// GetName 获取name的方法（Getter）
// 由于name是私有的，需要通过方法访问
func (p *Person) GetName() string {
    return p.name
}

// SetName 设置name的方法（Setter）
func (p *Person) SetName(name string) {
    p.name = name
}

// Introduce 方法
func (p *Person) Introduce() {
    fmt.Printf("大家好，我是%s，今年%d岁。\n", p.name, p.Age)
}

func main() {
    // 使用构造函数创建Person实例
    person := NewPerson("张三", 25)
    
    // 访问公共字段
    fmt.Println("年龄:", person.Age)
    
    // 通过方法访问私有字段
    fmt.Println("姓名:", person.GetName())
    
    // 修改私有字段
    person.SetName("李四")
    
    // 调用方法
    person.Introduce()
}

2. 继承（组合） 

 Go没有传统意义上的继承，而是通过结构体嵌入(embedding)实现组合。

package main

import "fmt"

// Animal 基类
type Animal struct {
    name string
}

// NewAnimal 构造函数
func NewAnimal(name string) *Animal {
    return &Animal{name: name}
}

// Speak 方法
func (a *Animal) Speak() {
    fmt.Println(a.name, "发出声音")
}

// Eat 方法
func (a *Animal) Eat() {
    fmt.Println(a.name, "正在吃东西")
}

// Dog 继承Animal
type Dog struct {
    *Animal          // 嵌入Animal，相当于继承
    Breed   string  // 狗的品种
}

// NewDog 构造函数
func NewDog(name, breed string) *Dog {
    return &Dog{
        Animal: NewAnimal(name),
        Breed:  breed,
    }
}

// Speak 方法重写
func (d *Dog) Speak() {
    fmt.Println(d.name, "汪汪叫")
}

// Fetch 子类特有方法
func (d *Dog) Fetch() {
    fmt.Println(d.name, "正在捡球")
}

func main() {
    animal := NewAnimal("普通动物")
    animal.Speak()
    animal.Eat()
    
    dog := NewDog("阿黄", "金毛")
    dog.Speak()    // 调用重写后的方法
    dog.Eat()      // 调用继承的方法
    dog.Fetch()    // 调用子类特有方法
    
    // 通过嵌入字段访问基类字段
    fmt.Println("狗的名字:", dog.name)
    fmt.Println("狗的品种:", dog.Breed)
}

 3. 多态（接口实现）

Go通过接口(interface)实现多态。

package main

import "fmt"

// Shape 接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Rectangle 矩形类
type Rectangle struct {
    width, height float64
}

// NewRectangle 构造函数
func NewRectangle(width, height float64) *Rectangle {
    return &Rectangle{width, height}
}

// Area 实现Shape接口的方法
func (r *Rectangle) Area() float64 {
    return r.width * r.height
}

// Perimeter 实现Shape接口的方法
func (r *Rectangle) Perimeter() float64 {
    return 2 * (r.width + r.height)
}

// Circle 圆形类
type Circle struct {
    radius float64
}

// NewCircle 构造函数
func NewCircle(radius float64) *Circle {
    return &Circle{radius}
}

// Area 实现Shape接口的方法
func (c *Circle) Area() float64 {
    return 3.14 * c.radius * c.radius
}

// Perimeter 实现Shape接口的方法
func (c *Circle) Perimeter() float64 {
    return 2 * 3.14 * c.radius
}

// PrintShapeInfo 多态函数，接受任何实现了Shape接口的类型
func PrintShapeInfo(s Shape) {
    fmt.Printf("面积: %.2f, 周长: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
    rect := NewRectangle(10, 5)
    circle := NewCircle(7)
    
    // 相同接口，不同表现
    PrintShapeInfo(rect)
    PrintShapeInfo(circle)
    
    // 接口类型断言
    if r, ok := rect.(*Rectangle); ok {
        fmt.Println("这是一个矩形，宽:", r.width, "高:", r.height)
    }
    
    // 类型开关(type switch)
    var s Shape = circle
    switch v := s.(type) {
    case *Rectangle:
        fmt.Println("矩形:", v.width, v.height)
    case *Circle:
        fmt.Println("圆形，半径:", v.radius)
    default:
        fmt.Println("未知形状")
    }
}

 4. 方法实现细节

Go中的方法可以绑定到任何类型（不仅仅是结构体），包括基本类型。 

package main

import (
    "fmt"
    "math"
)

// MyInt 自定义类型
type MyInt int

// Double 方法
func (m MyInt) Double() MyInt {
    return m * 2
}

// Point 结构体
type Point struct {
    X, Y float64
}

// DistanceTo 方法（值接收者）
func (p Point) DistanceTo(q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

// Scale 方法（指针接收者，会修改原值）
func (p *Point) Scale(factor float64) {
    p.X *= factor
    p.Y *= factor
}

// String 方法（实现Stringer接口）
func (p Point) String() string {
    return fmt.Sprintf("Point{X: %.2f, Y: %.2f}", p.X, p.Y)
}

func main() {
    // 自定义类型方法
    num := MyInt(5)
    fmt.Println(num.Double()) // 10
    
    // 结构体方法
    p1 := Point{1, 2}
    p2 := Point{4, 6}
    
    fmt.Println("距离:", p1.DistanceTo(p2)) // 5
    
    p1.Scale(2)
    fmt.Println(p1) // 使用String方法输出: Point{X: 2.00, Y: 4.00}
    
    // 指针与值的自动转换
    p3 := &Point{3, 4}
    fmt.Println("距离:", p3.DistanceTo(p2)) // Go会自动解引用
    
    p2.Scale(0.5) // Go会自动取地址
    fmt.Println(p2)
}

 5. 综合示例

package main

import (
    "fmt"
    "strings"
)

// Employee 基类
type Employee struct {
    name     string
    salary   float64
    vacation bool
}

// NewEmployee 构造函数
func NewEmployee(name string, salary float64) *Employee {
    return &Employee{
        name:     name,
        salary:   salary,
        vacation: false,
    }
}

// GetName Getter
func (e *Employee) GetName() string {
    return e.name
}

// GetSalary Getter
func (e *Employee) GetSalary() float64 {
    return e.salary
}

// TakeVacation 方法
func (e *Employee) TakeVacation() {
    e.vacation = true
}

// Work 方法
func (e *Employee) Work() {
    fmt.Printf("%s 正在工作...\n", e.name)
}

// String 方法
func (e *Employee) String() string {
    return fmt.Sprintf("员工: %s, 薪资: %.2f, 休假中: %v", 
        e.name, e.salary, e.vacation)
}

// Developer 子类
type Developer struct {
    *Employee         // 嵌入Employee
    language  string // 开发语言
}

// NewDeveloper 构造函数
func NewDeveloper(name string, salary float64, language string) *Developer {
    return &Developer{
        Employee: NewEmployee(name, salary),
        language: language,
    }
}

// Work 方法重写
func (d *Developer) Work() {
    fmt.Printf("%s 正在用 %s 写代码...\n", d.GetName(), d.language)
}

// Debug 特有方法
func (d *Developer) Debug() {
    fmt.Printf("%s 正在调试 %s 代码...\n", d.GetName(), d.language)
}

// Manager 子类
type Manager struct {
    *Employee        // 嵌入Employee
    team      []string // 团队成员
}

// NewManager 构造函数
func NewManager(name string, salary float64, team []string) *Manager {
    return &Manager{
        Employee: NewEmployee(name, salary),
        team:     team,
    }
}

// Work 方法重写
func (m *Manager) Work() {
    fmt.Printf("%s 正在管理团队: %s\n", 
        m.GetName(), strings.Join(m.team, ", "))
}

// ConductMeeting 特有方法
func (m *Manager) ConductMeeting() {
    fmt.Printf("%s 正在主持会议\n", m.GetName())
}

// Worker 接口
type Worker interface {
    Work()
    GetName() string
    GetSalary() float64
}

// Company 公司类
type Company struct {
    workers []Worker
}

// AddWorker 添加员工
func (c *Company) AddWorker(w Worker) {
    c.workers = append(c.workers, w)
}

// StartWorkDay 开始工作日
func (c *Company) StartWorkDay() {
    fmt.Println("===== 工作日开始 =====")
    for _, worker := range c.workers {
        worker.Work()
    }
    fmt.Println("===== 工作日结束 =====")
}

func main() {
    // 创建公司
    company := &Company{}
    
    // 创建员工
    dev1 := NewDeveloper("张三", 15000, "Go")
    dev2 := NewDeveloper("李四", 16000, "Python")
    manager := NewManager("王五", 25000, []string{"张三", "李四"})
    
    // 员工休假
    dev1.TakeVacation()
    
    // 添加员工到公司
    company.AddWorker(dev1)
    company.AddWorker(dev2)
    company.AddWorker(manager)
    
    // 开始工作
    company.StartWorkDay()
    
    // 调用特有方法
    dev2.Debug()
    manager.ConductMeeting()
    
    // 打印员工信息
    fmt.Println(dev1)
    fmt.Println(dev2)
    fmt.Println(manager)
}

关键概念总结

  1. 类与封装：Go使用结构体定义类，通过字段/方法名的大小写控制访问权限（大写公开，小写私有）

  2. 构造函数：Go没有真正的构造函数，通常使用NewXxx形式的工厂函数

  3. 继承：通过结构体嵌入实现组合式继承

  4. 多态：通过接口实现，任何实现了接口所有方法的类型都自动满足该接口

  5. 方法：可以绑定到任何类型，接收者可以是值或指针

  6. 接口：定义行为而非实现，是实现多态的关键

Go的面向对象方式与传统OOP语言有所不同，它更强调组合而非继承，通过接口实现多态，这种方式更灵活且避免了传统继承的许多问题。

golang学习笔记28——golang中实现多态与面向对象
GoppViper的博客
09-19 859
Go 语言并不是传统意义上的面向对象编程语言，但它通过一些独特的方式实现了类似面向对象编程（OOP）的特性，其中包括多态的实现。本文将详细介绍在 Go 语言中如何实现多态以及面向对象相关概念。虽然 Go 语言不是纯粹的面向对象语言，但它通过接口、封装和组合等特性，提供了一种灵活且高效的编程方式来实现多态和面向对象相关的编程模式。这些特性使得 Go 语言在复杂系统的构建中能够满足各种设计需求，同时保持了语言的简洁性和高效性。希望这篇文章能够帮助大家更好地理解 Go 语言在多态和面向对象方面的实现方式。
【Golang中的继承】
小墨蛇的博客
07-22 2264
继承是面向对象编程中的一种重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。在Golang中，没有明确的继承关键字，但可以通过嵌入结构体的方式来实现继承的效果。
Golang实现多态
Salted fish in hand, I have the world.
06-13 669
在Go中，接口就是方法签名method signature的集合，当一个类型实现了接口的所有方法，我们就称该类型实现了这个接口。定义一个接口可以进行文件读写： 2. 实现接口 3. 接口赋值 接口赋值在Go中包含两种情况：将对象实例赋值给接口 将一个接口赋值给另一个接口我们现在构造一个特殊的例子，意在指出将对象实例赋值给接口时可能出现的错误： 如果我们要将对象赋值给接口，那么下述两种写法是不同的： 错误的语句编译期间报错如下： 原因在于Go可以根据值传递版本的方法成员自动生成指针传递版本的方法成员，因此*
go中多态的实现
slnsuya的博客
04-07 1079
go中多态的实现，接口的具体分类，接口实现的几种情况
golang接口interface实现多态
kanguolaikanguolaik的专栏
08-06 1079
interface实现多态一、代码二、运行结果 一、代码 package main import ( "fmt" ) //interface type IPerson interface { Info() string } //teacher type Teacher struct { Name string } func (t *Teacher) Info() string { return "teacher name: " + t.Name } //student type Stude
Go 系列教程 —— 28. 多态
weixin_30737363的博客
08-15 319
欢迎来到Golang 系列教程的第 28 篇。 Go 通过接口来实现多态。我们已经讨论过，在 Go 语言中，我们是隐式地实现接口。一个类型如果定义了接口所声明的全部方法，那它就实现了该接口。现在我们来看看，利用接口，Go 是如何实现多态的。 使用接口实现多态 一个类型如果定义了接口的所有方法，那它就隐式地实现了该接口。 所有实现了接口的类型，都可以把它的值保存在一个接口类型的变...
【Golang】封装、继承、接口、多态
豆豆花的博客
01-22 1865
案例：写一个简单的AMT程序，实现存取款和查询功能。 package main ​ import ( "fmt" ) ​ type Pay struct { Account string Pwd string Money float64 } ​ func (pay *Pay) SaveMoney(num float64, pwd string) { if pwd != pay.Pwd { fmt.Println("密码输入错误") ...
Golang面向对象编程（一）
最新发布
2021dragon的博客
05-10 2056
Go支持面向对象编程特性，包括封装、继承和多态，但Go中没有类（class）而是基于结构体（struct）来实现OOP特性的。结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体，结构体中的成员称为结构体的字段。在编程过程中，通常将一类事物的特性提取出来，形成一个结构体类型，然后基于这个结构体类型创建出多个实例。结构体定义方式Go中结构体定义的基本语法如下：// 定义结构体Age int结构体是值类型，不同结构体变量的字段是独立的，互不影响。
《Golang入门系列》Golang的面向对象编程
weixin_42409057的博客
05-26 501
Go语言面向对象编程 引言 Golang也支持面向对象编程(OOP),但是和传统的面向对象编程有区别,并不是纯粹的面向对象语言。所以我们说 Golang支持面向对象编程特性是比较准确的。 Golang没有类(class),Go语言的结构体( struct)和其它编程语言的类class有同等的地位,你可以理解 Golang是基于 struct来实现OOP特性的。 Golang面向对象编程非常简洁,去掉了传统OOP语言的继承、方法重载、构造函数和析构函数、隐藏的this指针等等 Golang仍然有面向对象
Golang 面向对象全解
Lejeune的博客
05-24 1926
Golang 面向对象全解     golang的面向对象是不完备的面向对象，大部分人员都是从java转换而来，造成了很多的坑，这一篇文章记录我已知的golang面向对象性质和坑，希望后来者注意。 基础          首先面向对象具有三大特性，封装、继承、多态，golang均不直接支持这三种特性，但都可以通过别的方式来实现这三种特性。 封装 golang中没有class只有struc
go-实现多态
y943711797的博客
05-25 201
本文已参与「新人创作礼」活动，一起开启掘金创作之路# 1、go实现多态 Go中没有implements关键字，也没有extends，但并不意味着go不能实现多态和继承。 为了降低代码的耦合度，我们可以使用接口的方式来实现多态。 1、概述 相同的一类东西，因为有同样的行为，相同的行为我们可以写成接口，当同类去调用这个接口的时候会产生不一样的行为。任何用户定义的类型都可以实现任何接口，所以通过不同...
Go多态实现
北桥源木
04-29 715
Go本身不具有多态的特性，不能够像Java、C++那样编写多态类、多态方法。但是，使用Go可以编写具有多态功能的类绑定的方法。Go使用struct构建类，根据不同类调用不同的方法， 使用struct对象类型来消除了方法的模糊性。直接撸代码 package ch12 import ( "fmt" "testing" ) //实现多态 type Code string type P...
Go语言实现多态
weixin_43395911的博客
02-19 3623
多态是什么 相信学过Java这种面向对象语言的同学对于多态来说都不陌生，在代码执行的时候，能够根据子类的类型去执行子类当中的方法。多态是指代码可以根据类型的具体实现采取不同行为的能力。如果一个类型实现了某个接口，所有使用这个接口的地方，都可以支持这种类型的值。 Go语言多态举例 有这样一个场景，我们在应用开发中涉及到很多通知事件，通知的类型可以是通过微信、QQ、Email等，那么我们可以抽象出一个接口，定义一个通知的接口，然后微信通知类、QQ通知类、Email通知类分别实现对应的通知方法。 定义一个通知类
Go语言基础（二）封装继承多态、方法、接口
Sir的专栏
08-18 534
封装 go语言中可以简单地看作对struct的封装 type Person struct { name string } type Student struct { name string } type Teacher struct { name string } 继承 go语言中没有继承，但可以通过“匿名组合”实现继承 结构体继承，方法继承，方法重写 //父类 type Person struct { name string age int } type Stud
golang-多态的实现
mac的博客
09-13 251
package main import "fmt" type fun interface {//接口 process() } type A1 struct{ } type B1 struct{ } func (a *A1)process(){ fmt.Println("a") } func (b *B1)process(){ fmt.Println("b") } func Facto...
golang继承，和多态
热门推荐
积累
05-13 1万+
package main type ST struct{ } func (s *ST)Show(){     println("ST") } func (s *ST)Show2(){     println("ST:Show2()") } type ST2 struct{     ST     I int } func (s *ST2)Show(){
go中如何实现多态
jfkidear的专栏
03-21 1172
go中如何实现多态 痕无落关注 0.12016.04.24 10:57*字数 408阅读 6137评论 5喜欢 5 接触go快半年了， 但是还是属于那种用到时去搜索的状态， 没有系统的去研究研究 go是一种强类型的语言，每当我从php切换到go时总有些许的不适应，但是追求优雅，就不应该妥协。 go没有implements,extends关键字，所以习惯于OOP...
深入了解Go语言面向对象编程实战
资源摘要信息:"桫哥-GOlang-05面向对象课程是一门旨在帮助学习者深入理解和掌握Go语言面向对象编程的课程。基础部分的目的是为了帮助学员打下坚实的语法基础，而进阶部分则通过实战案例和框架封装，提升学员在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值