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.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,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,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,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,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,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,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,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,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,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,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,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,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,p.tel)
}

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

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

结论:
一样使用
原文链接:https://www.f2er.com/go/191294.html

猜你在找的Go相关文章