十、Golang学习笔记：面向对象（下）

最新推荐文章于 2024-09-01 19:51:00 发布
最新推荐文章于 2024-09-01 19:51:00 发布
阅读量259 收藏
点赞数 1
分类专栏： Golang语言开发 文章标签： go golang 多态 编程语言 go语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43759853/article/details/112603936
版权
本文详细介绍了Go语言中的面向对象编程，包括接口的定义与使用，多态的概念及其实现，以及在计算器案例中的应用。通过具体的代码示例展示了如何通过接口实现多态，并探讨了接口继承、类型断言以及空接口的使用。同时，文章还展示了如何在类创建过程中使用工厂方法，以及在类型检查中运用类型断言确保数据类型的正确性。
摘要由CSDN通过智能技术生成

Golang中面向对象的知识，包括接口的定义、多态的定义与实现、关于多态的应用案例、空接口、类型断言等等。

文章目录

接口简介

概念：规定了要做哪些事，具体做什么，接口不管，把所有有共性的方法定义在一起，任何其他类型只要实现这些方法就是实现了这个接口。

接口的定义方式

只是和接口中的方法同名

//type 接口名字 interface{方法声明}
type Personer interface{//接口名+er
    SayHello()
    Say()
}
type Student struct{
    
}
func  (s *Student) SayHello(){
    fmt.Println("老师好")
}
type Teacher struct{
    
}
func  (t *Teacher) SayHello(){
    fmt.Println("学生好")
}
func main(){
    //对象名.方法名
    var stu Student
    stu.SayHello()
    var teacher Teacher
    teacher.SayHello()
    //通过接口变量调用,必须都实现接口中所声明的方法
    var person Personer
    person = &stu
    person.SayHello()//调用的是student 实现的SayHello方法
    person = &teacher
    person.SayHello()//调用的是student 实现的SayHello方法    
}

多态定义与实现

概念：指多种变现形式，同一个接口，使用不同的实例而执行 不同的操作。

//func 函数名（参数 接口类型）{}
type Personer interface{//接口名+er
    SayHello()
}
type Student struct{
    
}
func  (s *Student) SayHello(){
    fmt.Println("老师好")
}
type Teacher struct{
    
}
func  (t *Teacher) SayHello(){
    fmt.Println("学生好")
}
//多态
func WhoSayHi(h Personer){
    h.SayHello()
}
func main(){
    var stu Student
    var teacher Teacher
    WhoSayHi(&stu)
    WhoSayHi(&teacher)
}

多态运用案例

计算器第一个版本

//1.第一个类
type Object struct{
    
}
//2.添加一个方法
func (o *Object) GetResult(numA int,numB int,op string){
    //1.添加参数
    //2.判断运算方式
    switch op{
        case "+":
        result=numA+numB
        case "-":
        result=numA-numB
    }
    return result
}
func main(){
    var obj Object
    num := obj.GetResult(8,6,"+")
    fmt.Println(num)
}

计算器第二个版本:改进提高安全性,运用接口

//加法类
type Add struct{
    Object
}
func (a *Add) GetResult() int{//方法的实现要和接口中方法的声明保持一致
    return a.sunA + a.numB
}
//减法类
type Sub struct{
	Object
}
func (s *Sub) GetResult() int{//方法的实现要和接口中方法的声明保持一致
    return s.sunA - s.numB
}
type Object struct{
    numA int
    numB int    
}
type Resulter interface{
    GetResult() int//有返回类型
}

func main(){
    add := Add{Object{10,20}}
    num := add.GetResult()
    fmt.Println(num)
    
    sub := Sub{Object{10,20}}
    num := sub.GetResult()
    fmt.Println(num)    
}

计算器第三个版本:对象创建问题

//加法类
type Add struct{
    Object
}
func (a *Add) GetResult() int{//方法的实现要和接口中方法的声明保持一致
    return a.sunA + a.numB
}
//减法类
type Sub struct{
	Object
}
func (s *Sub) GetResult() int{//方法的实现要和接口中方法的声明保持一致
    return s.sunA - s.numB
}
type Object struct{
    numA int
    numB int    
}
type Resulter interface{
    GetResult() int//有返回类型
}
//定义一个新的类，创建一个方法，在该方法中完成对象的创建
type OperatoeFactory sturct{
    
}
func (o *OperatoeFactory) CreateOperator(op string,numA int,numB int) int{
    switch op{
        case "+":
        add := Add{Object{numA,numB}}
        return OperatorWho(&add)
        case "-":
        sub := Sub{Object{numA,numB}}
        return OperatorWho(&sub)
        default :
        return 0
    }
}
func OperatorWho(h Resulter) int{//多态
    return h.GetResult()
}
func main(){
	var operator OperatorFactory
    num := operator.CreateOperator("+",20,10)
    fmt.Println(num)
}

接口继承与转换

type Humaner interface{
    SayHello()
}
type Personer interface{
    Humaner//继承接口
    Say()
}
type Student struct{
    
}
func (s *Student) SayHello(){
    fmt.Println("大家好")
}
func (s *Student) Say(){
    fmt.Println("你好")
}
func main(){
    var stu Student
    var per Personer
    per = &stu
    per.Say()
    per.SayHello()//可以调用所继承的接口中的方法
    
    //接口转换
    var h Humaner
    h = per
    //per = h错误
    h.SayHello()
}

空接口定义与使用

概念：不包括任何的方法，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值。

func main(){
    var i interface{}
    i = 123
    i = "abc"
    fmt.Println(i)
    
    //空接口类型切片
    var s[]intterface{}
    s = append(s,123,"abc",12.3)
    for j:=0;j<len(s);j++{
        fmt.Println(s[j])
    }       
}

类型断言

概念：可以判断空接口中存储的数据类型

语法：value,ok:=m.(T)

​ m：表示空接口类型变量

​ T：是断言的类型

​ value：变量m中的值

​ ok：布尔类型变量，如果断言成功为true，否则为false

func main(){
    var i interface{}
    i = 123
    value,ok := i.(int)

    if ok{
        fmt.Println(value+10)
    }else{
        fmt.Println("类型推断错误")
    }
}

空接口与类型断言综合应用

//加法类
type Add struct{
    Object
}
func (a *Add) GetResult() int{//方法的实现要和接口中方法的声明保持一致
    return a.sunA + a.numB
}
func (a *Add) SetData(data ...interface) bool{
    //1.对数据的个数进行校验
    var b bool = true
    if len(data)>2{
        fmt.Println("参数个数错误！")
        b = false
    }
    value,ok := data[0].(int)
    if !ok{
        fmt.Println("第一个数类型错误！")
        b = false
    }
    value1,ok1 := data[1].(int)
    if !ok{
        fmt.Println("第二个数类型错误！")
        b = false
    }
    a.numA = value
    a.numB = value1
    //2.类型校验
    reture b
}
//减法类
type Sub struct{
	Object
}
func (s *Sub) GetResult() int{//方法的实现要和接口中方法的声明保持一致
    return s.sunA - s.numB
}
func (s *Sub) SetData(data ...interface) bool{
    //1.对数据的个数进行校验
    var b bool = true
    if len(data)>2{
        fmt.Println("参数个数错误！")
        b = false
    }
    value,ok := data[0].(int)
    if !ok{
        fmt.Println("第一个数类型错误！")
        b = false
    }
    value1,ok1 := data[1].(int)
    if !ok{
        fmt.Println("第二个数类型错误！")
        b = false
    }
    s.numA = value
    s.numB = value1
    //2.类型校验
    reture b
}
//
type Object struct{
    numA int
    numB int    
}
type Resulter interface{
    GetResult() int//有返回类型
    SetData(data ...interface{}) bool//完成参数运算的数据的类型校验
}
//定义一个新的类，创建一个方法，在该方法中完成对象的创建
type OperatoeFactory sturct{
    
}
func (o *OperatoeFactory) CreateOperator(op string) Resulter{
    switch op{
        case "+":
        add := new(Add)
        return add
        case "-":
        sub := new(Sub)
        return sub
        default :
        return nil
    }
}
func OperatorWho(h Resulter) int{//多态
    return h.GetResult()
}
func main(){
	var operator OperatorFactory
    obj := num := operator.CreateOperator("+")
    b := obj.SetData(30,10)
    if b{
        num := OperatorWho(obj)
        fmt.Println(num)
    }
    
}
栽楞头子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go面向对象
yonggeit的博客
01-06 108
golang面向对象
纯，属虚构
04-18 2348
golang可以实现面向对象，C++能做的，golang基本也可以做。 1.简单继承 golang用组合来实现继承，父类实例的作为子类的匿名成员即可。     继承了父类的成员变量和成员方法。     同名的成员方法，无论完整函数签名是否相同，父类方法均被隐藏。     同名的变量，子类优先，父类的必须加上父类类型才能访问。 e.Human.SayHi() 在正常的设计中
go method使用
余功鹏的专栏
02-03 506
转载：https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.5.md method 现在假设有这么一个场景，你定义了一个struct叫做长方形，你现在想要计算他的面积，那么按照我们一般的思路应该会用下面的方式来实现 package main import "fm
go-面向对象
wxy
05-02 386
go-面向对象
GO 面向对象
lucky404的博客
06-24 921
在 go 里面的面向对象没有class 的说法, go 还是使用func 和 结构体来实现面向对象编程, 并且可以实现继承和重写 例如 我定义一个 Person 对象， 它具有若干个属性, 其中的Action 是匿名字段 type Person struct { name string // 姓名 gender string // 性别 age int ...
Golang编程基础第二篇——Golang的面向对象
lishinho的博客
02-22 1227
Golang作为一种“更好的C语言“，提供了面向对象编程思想的支持。 一，类型系统 在go中你可以为任何类型添加相应的方法： //为类型添加方法 type Integer int //面向对象操作，对象是Integer这个类型的a值 func (a Integer) Less(b Integer) bool { return a < b } //面向对象调用 func m...
Go语言学习笔记—golang接口与实现面向对象特性
qq_39280718的博客
06-25 806
golang没有面向对象的概念，但是通过接口可实现面向对象的特性——继承封装多态
Golang学习笔记（六）：struct
09-22
这篇Golang学习笔记主要探讨了struct的声明与初始化、匿名字段（继承）、方法以及方法的继承与重写。 1. 声明及初始化： 在Golang中，我们可以使用`type`关键字来声明一个新的struct类型。例如，定义一个`person`...
golang-learning:高朗的笔记本
05-06
《Golang学习笔记：深入探索Go语言编程世界》 Golang，由Google开发的开源编程语言，因其简洁、高效和并发特性而备受开发者喜爱。"golang-learning"是一份全面的Go语言学习资源，旨在帮助程序员们深入理解并熟练...
golang的学习笔记
04-21
《Golang学习笔记》第四版，是一份深入探讨Go语言的宝贵资料，旨在帮助开发者全面理解和掌握这门现代、高效且简洁的后端开发语言。Go语言，又称Golang，由Google公司于2009年推出，由Robert Griesemer、Rob Pike及...
GO面向对象
u011409264的专栏
12-16 384
GO面向对象GO中没有隐藏的this指针类型系统类型系统是一个语言的类型体系，GO的类型系统包含以下基本内容： - 基础类型，如byte、int、bool、float等 - 复合类型，如数组、结构体、指针等 - 可以指向任意对象的类型 - 值语义和引用语义 - 面向对象，即所有具备面向对象特征的类型 - 接口GO语言的类型系统： - 给任意类型添加响应的方法type Integer i
go 面向对象
衡与墨的博客
04-06 2545
概述 go的面向对象和其它的面向语言并不太相同。首先，go是没有类的概念的，在go中数据是数据，方法是方法，二者比较独立。其次go对继承的实现更像是“组合”。go的接口是鸭子类型：只要你像个鸭子，那么我就认为你是个鸭子，而不需要显式的实现接口，像java的implements XXX在go是不存在的。 面向对象的三个特征：继承、封装、多态 go都可以实现。（多态需要基于接口实现） 基础语法 type User struct { name string } func (u User) introduceM
go面向对象
青石玄霄
06-10 171
把一类事物的共有的 属性( 字段)和 行为( 方法)提取出来，形成一个 物理模型(结构体)。这种研究问题的方法称为抽象 封装(encapsulation)就是把抽象出的字段和对字段的操作封装在一起,数据被保护在内部,程序的其它包只有通过被授权的操作(方法),才能对字段进行操作 封装的好处 1) 隐藏实现细节 2) 可以对数据进行验证，保证安全合理 封装的实现步骤 1) 将结构体、字段(属性)的首字母小写(不能导出了，其它包不能使用，类似 private) 2) 给结构体所在包提供一个工厂模式的函数，首字
Go 面向对象
molaifeng的专栏
10-31 343
引言 Go 的面向对象，语法清奇，思路独特，和传统的面向对象语言如 Java 完全不同，可开阔思路。 结构体 谈到面向对象，就不得不提其载体 struct type 结构体名称 struct{ field1 type field2 type } 以上便是其定义的语法，使用也很简单 type Student struct { Name,Address string Age in...
【Go】面向对象
weixin_44209726的博客
05-08 341
【Go】面向对象 一、面向对象的三大特征 （一）封装：隐藏对象的属性和实现细节，仅对外提供访问方式 （二）继承：使得子类具有父类的属性和方法或重新定义、追加方法和属性等 （三）多态：不同对象中同种行为的不同实现方式 二、go实现封装 使用 type [name] struct{}可以定义一个结构体，包含任意其他类型。 type parent struct { son1 int son2 string son3 []int } func main() { p := parent{
Go 中的面向对象
不求前途凶吉，但求落幕无悔！
04-07 256
我们总结一下前面看到的：Go 没有类，而是松耦合的类型、方法对接口的实现。 OO 语言最重要的三个方面分别是：封装，继承和多态，在 Go 中它们是怎样表现的呢？ 封装（数据隐藏）：和别的 OO 语言有 4 个或更多的访问层次相比，Go 把它简化为了 2 层（参见 4.2 节的可见性规则）: 1）包范围内的：通过标识符首字母小写，对象 只在它所在的包内可见 2）可导出的...
Go语言的编程规则和秘籍
最新发布
一个被知识诅咒的人
09-01 933
本文介绍了Go语言的两条关键编程规则及其相关操作。首先，Go语言要求所有导入的包必须在代码中实际使用，未使用的包会导致编译错误。通过在包名前添加下划线，可以避免此限制但不建议这样做。其次，Go对大括号的使用有严格要求，大括号必须与函数声明在同一行，否则会引发编译错误。此外，本文还介绍了如何下载和管理外部Go包，使用`go get`命令可以轻松获取并编译外部包，并展示了删除中间文件和包的方法。了解并遵循这些规则有助于编写更高质量的Go代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值