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

最新推荐文章于 2025-08-12 22:58:22 发布
原创 最新推荐文章于 2025-08-12 22:58:22 发布 · 4.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang #继承 #方法

本文详细测试了Golang中通过嵌入字段或指针实现继承的不同情形，验证了其设计思路及使用方法，包括结构内嵌入、匿名字段、方法传递等场景。
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() // 匿名字段，相当于匿名结构直接嵌入，在同一层面
}

结论：
     一样使用



【Golang中的继承】
小墨蛇的博客
07-22 2315
继承是面向对象编程中的一种重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。在Golang中，没有明确的继承关键字，但可以通过嵌入结构体的方式来实现继承的效果。
golang面向对象之继承
青梅煮酒
04-28 483
1、看一个问题，引出继承的必要性   一个小问题，看一个学生考试系统的程序，提出代码复用的问题。 package main import "fmt" //编写一个学生考试系统 type Pupil struct { Name string Age int Score int } //显示他的成绩 func (p *Pupil) ShowInfo() { fmt.Printf("...
Golang中的"继承"
ljlinjiu的博客
03-31 3713
go语言是没有继承的，但结构体支持匿名字段，可以利用这个来实现“继承”。 类Human。有2个字段：name,sex。有2个方法：walk，eat。 类SuperMan。有3个字段：Human，name，level。有2个方法：eat，fly。 这是标准说法，但你可以这么理解：SuperMan继承了Human，当然同样继承了所有字段和所有方法。同时又加入了自己的两个字段，其中有一个字段和父类...
38-Golang中的继承
weixin_49750432的博客
02-24 1431
1.继承可以解决代码复用，让我们编程更加靠近人类思维2.当多个结构体存在相同的属性(字段)和方法时，可以从这些结构体中抽象出结构体，在该结构体中定义这些相同的属性和方法3.其他的结构体不需要重新定义这些属性(字段）和方法，只需嵌套一个匿名结构体即可4.也就是说：在golang中，如果一个struct嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现继承特性。
Golang继承
umgsai的专栏
05-15 279
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】封装、继承、接口、多态
豆豆花的博客
01-22 1893
案例：写一个简单的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中读写锁的底层实现
qq_42538588的博客
07-16 1422
读写锁是一种并发控制机制，它允许多个线程同时对共享资源进行读访问，但在进行写操作时需要互斥访问，以确保数据的一致性和完整性。读写锁的主要功能是提高系统在读多写少场景下的并发处理能力，从而提升整体性能。读写锁在实际应用中扮演着重要的角色，可以有效地降低系统的并发访问冲突，提高系统的并发处理能力，同时也能够避免写操作对读操作的阻塞，从而减少了线程的等待时间，提升了系统的整体响应速度。w Mutex // 互斥锁L *Locker本文介绍了如何在Go语言中使用读写锁的应用实例。
golang基础
weixin_44320429的博客
06-10 1163
定义type 类型名 struct {字段名 字段类型字段名 字段类型… }其中1.类型名：标识自定义结构体的名称，在同一个包内不能重复。2.字段名：表示结构体字段名。结构体中的字段名必须唯一。3.字段类型：表示结构体字段的具体类型。只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。//结构体的定义：使用type和struct关键字age int32//常用的结构体实例化方式一：使用键值对初始化age: 19,//实例化方式二。
Golang笔记——Interface类型
m0_67390788的博客
02-10 1178
接口定义了类型应该具备的行为（即方法）。Go 的接口与其他语言（如 Java 或 C++）中的接口有一些不同之处，特别是Go 的接口不需要显式声明实现，即只要类型实现了接口的方法，就自动实现了该接口。Method1() // 方法签名Method2() // 方法签名类型断言：用于在运行时提取接口的具体类型值，如果类型不匹配，可以使用ok变量避免运行时错误。类型开关：允许你对接口值的动态类型进行多分支判断，可以在多个可能的类型之间选择。反射：通过reflect包可以。
11 go语言（golang） - 数据类型：结构体
瑞瑞的博客
11-11 995
一个结构体由一组字段（field）组成，每个字段都有一个名称和类型。可以通过type关键字来定义一个新的结构体类型。结构体的字段可以是任何类型，包括基本类型、其他结构体、切片、哈希表等。对于包含不可比元素的数据类型，你可以通过自定义方法来实现自己的“相等”逻辑。// Equal 方法用于判断两个 Student 是否“相等”if s1.num!var s1 = Student{1, "小明", func() string { return "x" }}
golang 继承
python基础
03-16 286
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的继承
最新发布
T18357726647的博客
08-12 767
Go语言通过结构体嵌套实现继承机制，核心要点包括： 继承通过匿名嵌套结构体实现，子结构体自动获得父结构体的字段和方法 访问规则遵循就近原则，同名时需显式指定结构体名 不同包中只能访问大写字母开头的字段和方法 支持多重继承，但需避免同名冲突 与组合的区别在于是否使用匿名结构体 继承提高了代码复用性，如商品-书示例所示，通过Good结构体嵌套，Book自动获得name/price等属性和相关方法。需要注意的是Go更推荐组合而非复杂的多重继承。
golang：方法的继承
OceanStar的博客
06-11 368
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 3154
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记，并与大家分享，侵权即删，谢谢支持！ 附上汇总贴：Go语言自学系列 | 汇总_COCOgsta的博客-优快云博客 golang本质上没有oop的概念，也没有继承的概念，但是可以通过结构体嵌套实现这个特性。 例如 package main import "fmt" type Animal struct { name string
golnag实现继承
qq_44813641的博客
01-12 414
golang中没有继承，本文将介绍如何用golang实现继承功能。
[Golang] 谈Go中的继承
热门推荐
Rei的博客
10-26 1万+
继承，这个概念来自于OOP思想。 所谓继承，是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 继承的关键词：“获得”，“代码复用”。 先来看看典型的OOP语言Python对于继承的实现： class person: def say(self......
Golang 继承
hitpter的专栏
10-27 446
在面向对象的编程语言中，继承是一种重要的机制，它允许子类继承父类的属性和方法。然而，Go语言在设计时没有直接支持传统意义上的继承，而是提供了一种更为灵活和简洁的方式来实现类似的功能。本文将探讨Golang中实现继承的方法和最佳实践。
Golang中的面向对象继承
purple尘的专栏
01-11 562
转自：http://hackthology.com/golangzhong-de-mian-xiang-dui-xiang-ji-cheng.html Golang的面向对象机制与Smalltalk或者Java等传统面向对象的编程语言不同。传统面向对象编程语言的一个重要特性是继承机制。因为继承机制支持在关联对象间进行代码复用和数据共享。继承机制曾在代码复用和数据共享的设计模式占据
golang中如何attach结构体，并读取结构体数据
05-27
<think>好的，用户想了解如何在Golang中附加结构体并读取其数据。首先，我需要明确“附加结构体”具体指什么。在Golang中，常见的结构体操作包括组合、嵌套、嵌入以及使用指针或值方法进行操作。可能用户指的是将结构体嵌入到另一个结构体中，或者通过某种方式关联两个结构体，以便访问数据。 接下来，我需要考虑如何解释结构体的组合和嵌入。Golang中没有继承，但可以通过嵌入结构体来实现类似的效果。例如，一个结构体可以嵌入另一个结构体，从而获得被嵌入结构体的字段和方法。这可能就是用户所说的“附加”结构体。然后，关于读取数据，需要说明如何通过点操作符访问嵌入结构体的字段，或者如果使用嵌套结构体，可能需要指定中间字段名。此外，可能需要提到标签（tags）的使用，比如JSON或XML标签，用于序列化和反序列化数据，但用户的问题可能更偏向于结构体之间的组合而非数据格式的转换。 还需要考虑用户可能的实际应用场景，比如是否在构建一个具有扩展性的系统，或者处理某种数据存储问题。根据用户提供的引用，他们之前提到了MapReader结构体，其中包含缓存和头信息，可能用户想了解如何将不同的结构体组合在一起，比如将读取器与缓存结合，或者处理错误信息的结构体附加到主结构体上。另外，用户提供的引用中有关于错误处理的例子，使用指针接收器实现错误接口。这可能暗示用户对结构体方法以及接口实现也有兴趣，需要将这部分知识结合起来。需要确保回答的结构清晰，分步骤说明如何嵌入结构体，如何访问数据，可能还需要提到结构体标签的使用，以及通过方法操作结构体数据。同时，要给出代码示例，这样用户能更直观地理解。例如，展示一个包含嵌入结构体的例子，并演示如何访问其字段。 此外，需要注意用户提到的“附加”可能是指动态附加，但Golang是静态类型语言，无法在运行时动态附加结构体，但可以通过组合、接口或者使用map等方式来模拟。因此，需要明确说明Golang的结构体组合是编译时确定的，但可以通过设计模式来灵活使用。 最后，生成相关问题，帮助用户进一步学习，比如结构体嵌入与继承的区别，如何实现嵌套结构体的JSON序列化，或者结构体方法的指针与值接收器的区别等。</think>在Go语言中实现结构体的关联和数据读取，主要通过结构体组合、字段标签和反射机制实现。以下是具体实现方法： ### 一、结构体组合（嵌套） 通过嵌套结构体实现数据关联： ```go type Address struct { City string `json:"city"` Street string `json:"street"` } type User struct { Name string `json:"name"` Age int `json:"age"` Address Address `json:"address"` // 嵌套结构体 } func main() { user := User{ Name: "张三", Age: 30, Address: Address{ City: "北京", Street: "朝阳路", }, } // 读取嵌套数据 fmt.Println(user.Address.City) // 输出：北京 } ``` 这种组合方式在编译时确定类型关系，是Go语言推荐的结构设计方式[^3]。 ### 二、动态附加结构体 对于需要运行时动态附加数据的场景，可以使用以下方法： 1. **使用匿名结构体**： ```go type Base struct { ID int } func main() { extended := struct { Base Name string }{ Base: Base{ID: 1}, Name: "测试", } fmt.Println(extended.ID) // 输出：1 } ``` 2. **通过接口实现动态附加**： ```go type Attachable interface { Attach(key string, value interface{}) Get(key string) interface{} } type Container struct { data sync.Map } func (c *Container) Attach(key string, value interface{}) { c.data.Store(key, value) } func (c *Container) Get(key string) interface{} { val, _ := c.data.Load(key) return val } ``` ### 三、反射读取结构数据 使用`reflect`包读取结构体字段信息： ```go func PrintStruct(s interface{}) { val := reflect.ValueOf(s) typ := val.Type() for i := 0; i < val.NumField(); i++ { field := typ.Field(i) value := val.Field(i) fmt.Printf("%s (%s): %v\n", field.Name, field.Type, value.Interface()) } } ``` ### 四、结构体标签解析 结合反射读取字段标签： ```go type Example struct { Field string `customTag:"important"` } func main() { e := Example{"value"} t := reflect.TypeOf(e) field, _ := t.FieldByName("Field") fmt.Println(field.Tag.Get("customTag")) // 输出：important } ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值