Golang继承中字段及方法的测试

最新推荐文章于 2024-09-26 21:39:09 发布
最新推荐文章于 2024-09-26 21:39:09 发布
阅读量4.8k 收藏
点赞数 1
分类专栏： Golang 文章标签： golang 继承 方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/max2005/article/details/9416387
版权
Golang采用嵌入字段来实现继承，由于实现上存在多种可能，这里进行测试，看看Golang的设计思路。

待考察的问题包括：
     嵌入的是结构，还是指针？
     嵌入部分是匿名字段，还是命名字段？
     方法是传值，还是传指针？

最终结论：
     可以嵌入字段，也可以嵌入指针，其特性吻合惯性思维
     无论字段是否指针，无论方法的接收者是否指针，在字段引用时都不区分指针

以下是测试过程

     一共4组不同情形的测试
          结构中有另一个结构，这是最简单的情形
          结构中有一个匿名结构，测试用类型代替字段名，或直接引用
          结构中有指针指向另一个结构
          结构中有匿名指针指向另一个结构

     每组测3个项目
          继承后的引用
          传值方法的继承
          传指针方法的继承

     故一共12个测试



第1组测试
     结构中有另一个结构，这是最简单的情形


package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    person Person   // 有另一个字段
    school   string
}


func   main() {
    anna := new(Student)
    anna.person.name =   "Anna"
    anna.person.tel =   "12345678"
      //anna.school = "mit"
 
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , anna.person.name, anna.person.tel)
 
}


第1.1组测试
     结构中有另一个结构，这是最简单的情形
     测试这种情况下方法的继承

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    person Person   // 有另一个字段
    school   string
}

//在person上面定义了一个传值的method
func   (p Person) Hello() {
    fmt.Printf( "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}
func   main() {
    anna := new(Student)
    anna.person.name =   "Anna"
    anna.person.tel =   "2345678"
      //anna.school = "mit"
     
        // anna.Hello() // 这是不行的，非匿名字段不能直接引用
      anna.person.Hello()
     
      //fmt.Printf( "My name is %s, and my tel number is %s\n", anna.person.name, anna.person.tel)
}

结论：
     如果字段没有匿名，则相当于中间隔了一层，不能跨越去引用

第1.2组测试
     结构中有另一个结构，这是最简单的情形
     测试这种情况下方法的继承
     但是定义传指针的method

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    person Person   // 有另一个字段
    school   string
}

//在person上面定义了一个传指针的method
func   (p * Person) Hello() {
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}
func   main() {
    anna := new(Student)
    anna.person.name =   "Anna"
    anna.person.tel =   "345678"
      //anna.school = "mit"
    
         // anna.Hello() // 这是不行的，非匿名字段不能直接引用
      anna.person.Hello()
    
      //fmt.Printf( "My name is %s, and my tel number is %s\n", anna.person.name, anna.person.tel)
}

结论：
     没有问题，method传值或传指针没有区别

第2组测试
     结构中有一个匿名结构，测试用类型代替字段名，或直接引用

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    Person   // 有一个匿名字段
    school   string
}


func   main() {
    anna := new(Student)
    anna.Person.name =   "Anna"   // 用类型代替字段名
    anna.tel =   "123456789"   // 或者直接引用
      //anna.school = "mit"
 
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , anna.Person.name, anna.tel)
 
}



第2.1组测试
     结构中有一个匿名结构
     测试这种情况下方法的继承


package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    Person   // 有另一个字段
    school   string
}

//在person上面定义了一个传值的method
func   (p Person) Hello() {
    fmt.Printf( "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}
func   main() {
    anna := new(Student)
    anna.Person.name =   "Anna"
    anna.tel =   "2345"
      //anna.school = "mit"
     
      anna.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
     
      //fmt.Printf( "My name is %s, and my tel number is %s\n", anna.person.name, anna.person.tel)
}

结论：匿名字段，相当于匿名结构直接嵌入，在同一层面

第2.2组测试
     结构中有一个匿名结构
     测试这种情况下方法的继承
     但是定义传指针的method

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    Person   // 有另一个字段
    school   string
}

//在person上面定义了一个传指针的method
func   (p * Person) Hello() {
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}
func   main() {
    anna := new(Student)
    anna.Person.name =   "Anna"
    anna.tel =   "345"
      //anna.school = "mit"
    
      anna.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
    
      //fmt.Printf( "My name is %s, and my tel number is %s\n", anna.person.name, anna.person.tel)
}

结论：
     传指针无影响

第3组测试
     结构中有指针指向另一个结构

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    person * Person   // 指针指向一个字段
    school   string
}


func   main() {
    anna := new(Student)
    anna.person = new(Person)   // 必须，否则panic
    anna.person.name =   "Anna"
    anna.person.age = 22
    anna.person.tel =   "12345"
    anna.school =   "mit"
  
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , anna.person.name, anna.person.tel)
  
}


第3.1组测试
     结构中有指针指向另一个结构
     测试方法的继承

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    person * Person   // 指针指向一个字段
    school   string
}

//在person上面定义了一个传值的method
func   (p Person) Hello() {
    fmt.Printf( "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}

func   main() {
    anna := new(Student)
    anna.person = new(Person)
    anna.person.name =   "Anna"
    anna.person.tel =   "234567"
     
      anna.person.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
     
}

结论：
     非常正常的使用

第3.2组测试
     结构中有指针指向另一个结构
     测试方法的继承
     但是定义传指针的method

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    person * Person   // 指针指向一个字段
    school   string
}

//在person上面定义了一个传指针的method
func   (p * Person) Hello() {
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}

func   main() {
    anna := new(Student)
    anna.person = new(Person)
    anna.person.name =   "Anna"
    anna.person.tel =   "345678"
    
      anna.person.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
    
}

结论：
     指针无影响

第4组测试
     结构中有匿名指针指向另一个结构

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    * Person   // 匿名指针指向一个字段
    school   string
}


func   main() {
    anna := new(Student)
    anna.Person = new(Person)
    anna.Person.name =   "Anna"
      //anna.Person.age = 22
    anna.tel =   "123"
      //anna.school = "mit"
 
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , anna.Person.name, anna.tel)
 
}

结论：
     anna.Person = new(Person) 居然也行
     匿名相当于直接嵌入，在同一层面
     Golang似乎是尽量识别，如果有字段名，包括指针，则必须用字段名，如果是匿名，则可用匿名字段的类型
  
第4.1组测试
     结构中有匿名指针指向另一个结构
     测试方法的继承

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    * Person   // 匿名指针指向一个字段
    school   string
}


//在person上面定义了一个传值的method
func   (p Person) Hello() {
    fmt.Printf( "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}

func   main() {
    anna := new(Student)
    anna.Person = new(Person)
    anna.Person.name =   "Anna"
    anna.tel =   "23456789"

     
      anna.Person.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
      anna.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
}

结论
     在同一层面，当然加上匿名指针也可

第4.2组测试
     结构中有匿名指针指向另一个结构
     测试方法的继承
     但是定义传指针的method

package   main
import   "fmt"

type   Person   struct   {
    name   string
    age   int
    tel   string
}

type   Student   struct   {
    * Person   // 匿名指针指向一个字段
    school   string
}


//在person上面定义了一个传指针的method
func   (p * Person) Hello() {
    fmt.Printf(   "My name is %s, and my tel number is %s\n" , p.name, p.tel)
}

func   main() {
    anna := new(Student)
    anna.Person = new(Person)
    anna.Person.name =   "Anna"
    anna.tel =   "34"

    
      anna.Person.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
      anna.Hello()   // 匿名字段，相当于匿名结构直接嵌入，在同一层面
}

结论：
     一样使用



Max2005
关注
专栏目录
【Golang中的继承】
小墨蛇的博客
07-22 2089
继承是面向对象编程中的一种重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。在Golang中，没有明确的继承关键字，但可以通过嵌入结构体的方式来实现继承的效果。
【Golang】封装、继承、接口、多态
豆豆花的博客
01-22 1792
案例：写一个简单的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中的"继承"
ljlinjiu的博客
03-31 3656
go语言是没有继承的，但结构体支持匿名字段，可以利用这个来实现“继承”。 类Human。有2个字段：name,sex。有2个方法：walk，eat。 类SuperMan。有3个字段：Human，name，level。有2个方法：eat，fly。 这是标准说法，但你可以这么理解：SuperMan继承了Human，当然同样继承了所有字段和所有方法。同时又加入了自己的两个字段，其中有一个字段和父类...
golang学习笔记21-面向对象（三）：封装与继承【重要】
最新发布
技术卷的博客
09-26 1098
本节也是GO核心部分，很重要。封装(encapsulation)就是把抽象出的字段和对字段的操作封装在一起，数据被保护在内部程序的其它包只有通过被授权的操作方法，才能对字段进行操作。继承的概念和C++一样，就不做赘述了，但GO其实是弱化了这个概念，没有专门的机制来实现继承，具体来说，没有父类子类的概念，没有继承关键字，但可以通过匿名结构体实现。首先，在
38-Golang中的继承
weixin_49750432的博客
02-24 1326
1.继承可以解决代码复用，让我们编程更加靠近人类思维2.当多个结构体存在相同的属性(字段)和方法时，可以从这些结构体中抽象出结构体，在该结构体中定义这些相同的属性和方法3.其他的结构体不需要重新定义这些属性(字段）和方法，只需嵌套一个匿名结构体即可4.也就是说：在golang中，如果一个struct嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现继承特性。
Golang继承
umgsai的专栏
05-15 235
type Student struct { Name string Age int } func (s Student) test() { fmt.Println("student test....") } func (s Graduate) test() { fmt.Println("Graduate test....") } type Pupil struct { Student } type Graduate struct { Student } func main() { .
golang 继承
python基础
03-16 230
go语言的继承就是一个结构体内置了另一个结构体，从而外层机构体就可以调用内层结构体。 package main import "fmt" type animal struct { name string } type dog struct { feet uint8 animal } func (d animal) move() { fmt.Println("move") } func (d dog) bark() { fmt.Println("w a n g ") } func mai
golang 导入自定义包_goLang引入自定义包的方法
weixin_39611008的博客
12-20 2195
goLang引入自定义包的方法看完golang的基本语法后，为了模块化编程，试用了下golang的包管理，结果真踩了几个坑，总结一下吧。一. 设置$GOPATH环境变量golang和C或php不一样，不会自动查找当前路径下的文件，必须先在$GOAPTH里添加自己工程的路径；二. 自定义包里面对外提供的API函数，首字母必须大写如：func api() string {return “hello a...
ORM字段及操作
m0_69965929的博客
06-27 401
在模型层类中的字段即是数据库中表的字段，表的字段设计非常重要每一个字段都是基类的一个实例（类用来建立字段与数据库之间的映射）模型字段定义不能以下划线结尾django 会根据在模型类中定义的字段属性来确定以下几点工作 表单类型：CheckboxInput， CharField 表单类型：TextInput， DateField 注意：避免矛盾，，，不能同时出现，一个字段属性只能有其中一条设置，当设置了，或时，也会让该字段默认具有（字段可以为空）属性 表单类型：TextInput， Date
golang的context
qq_41078889的博客
04-01 1507
1.context简介 在go的http包的server中，每一个对应的请求都有一个goroutine负责处理，处理函数通常会启动额外的goroutine去处理，如果一个请求被取消或者超时，用来处理该请求的goroutine应该及时退出，这样就不会有大量的goroutine去占用资源。 Context类型专用来简化对于处理单个请求的多个goroutine之间与请求域的数据、取消信号、截止时间等相关操作，这些操作可能涉及多个API调用。因此对服务器的请求应该去创建上下文，对服务器的传输调用也应该接收上下文
Golang相关面试题
qq_40155502的博客
11-20 1434
个人整理的面试问题
golang：方法的继承
OceanStar的博客
06-11 321
package main import "fmt" type Person struct { name string //名字 sex byte //性别, 字符类型 age int //年龄 } //Person类型，实现了一个方法 func (tmp *Person) PrintInfo() { fmt.Printf("name=%s, sex=%c, age=%d\n", tmp.name, tmp.sex, tmp.age) } //学生，继承Person字段，
Go语言自学系列 | golang继承
COCO_gsta的博客
04-25 3090
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记，并与大家分享，侵权即删，谢谢支持！ 附上汇总贴：Go语言自学系列 | 汇总_COCOgsta的博客-CSDN博客 golang本质上没有oop的概念，也没有继承的概念，但是可以通过结构体嵌套实现这个特性。 例如 package main import "fmt" type Animal struct { name string
[Golang] 谈Go中的继承
热门推荐
Rei的博客
10-26 1万+
继承，这个概念来自于OOP思想。 所谓继承，是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 继承的关键词：“获得”，“代码复用”。 先来看看典型的OOP语言Python对于继承的实现： class person: def say(self......
Golang 继承
hitpter的专栏
10-27 335
在面向对象的编程语言中，继承是一种重要的机制，它允许子类继承父类的属性和方法。然而，Go语言在设计时没有直接支持传统意义上的继承，而是提供了一种更为灵活和简洁的方式来实现类似的功能。本文将探讨Golang中实现继承的方法和最佳实践。
Golang中的面向对象继承
purple尘的专栏
01-11 517
转自：http://hackthology.com/golangzhong-de-mian-xiang-dui-xiang-ji-cheng.html Golang的面向对象机制与Smalltalk或者Java等传统面向对象的编程语言不同。传统面向对象编程语言的一个重要特性是继承机制。因为继承机制支持在关联对象间进行代码复用和数据共享。继承机制曾在代码复用和数据共享的设计模式占据
golang面向对象之继承
青梅煮酒
04-28 445
1、看一个问题，引出继承的必要性   一个小问题，看一个学生考试系统的程序，提出代码复用的问题。 package main import "fmt" //编写一个学生考试系统 type Pupil struct { Name string Age int Score int } //显示他的成绩 func (p *Pupil) ShowInfo() { fmt.Printf("...
Golang学习(二十一） 面向对象--继承
默子昂
02-24 1754
什么是继承，为什么要继承 我们先看一个案例 package main import "fmt" //比如我们现在有个需求，打印一个小学生的成绩和基本信息，则代码如下 type Pupil struct{ Name string Age int Score int } //为Pupil绑定3个方法，显示 func (p *Pupil) ShowInfo(){ fmt.Printf("学生名=%v 年龄=%v 成绩=%v\n",p.Name,p.Age,p.Score) } // 设置.
golang 继承
03-02
通过这种方式，嵌入的结构体可以继承被嵌入结构体的字段和方法。嵌套结构体可以访问被嵌入结构体的字段和方法，就像它们是自己的一样。 下面是一个示例代码，演示了结构体嵌套的继承效果： ```go package main ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值