1.实例不转换为接口的情况下无区别
总结:
不转换为接口时(字段继承和字段指针继承)无区别,
在代码中1,2,3,4处(即a,b,pa,pb)都可以正常调用父类的函数
package main
import "fmt"
type iter interface {
run()
sleep()
}
type base struct{}
func (p *base)run() {
fmt.Println("Base::run()")
}
func (p base)sleep() {
fmt.Println("Base::sleep()")
}
type subA struct {
base // 字段继承
}
type subB struct {
*base // 字段指针继承
}
/**
总结:
不转换为接口时(字段继承和字段指针继承)无区别,就是正常类型实例使用
在1,2,3,4处(即a,b,pa,pb)都可以正常调用父类的函数
*/
func main() {
// 实例[字段继承]
a := subA{base{}}
a.run() // 1
a.sleep()
// 实例[字段指针继承]
b := subB{&base{}}
b.run() // 2
b.sleep()
// 指针实例[字段继承]
pa := &subA{base{}}
pa.run() // 3
pa.sleep()
// 指针实例[字段指针继承]
pb := &subB{&base{}}
pb.run() // 4
pb.sleep()
}
2.实例转换接口时有区别
总结:
转换为接口时(字段继承和字段指针继承)有区别,
在B1,C1,D1都可以正常运行
在A1处出现错误,即subA实例[字段继承]未实现接口 run()方法
package main
import "fmt"
type iter interface {
run()
sleep()
}
type base struct{
}
func (p *base)run() {
fmt.Println("Base::run()")
}
func (p base)sleep() {
fmt.Println("Base::sleep()")
}
type subA struct {
base
}
// ---------HERE------------
//func (p subA)run() {
// fmt.Println("Base::run()")
//}
type subB struct {
*base
}
/**
总结:
转换为接口时(字段继承和字段指针继承)有区别,
在B1,C1,D1都可以正常运行
在A1处出现错误,即subA实例[字段继承]未实现接口run()方法
*/
func main() {
// ======实例转换为接口=============
var i iter
// a实例[字段继承]
a := subA{base{}}
// 如果需要将a实例转化为接口,必须实现接口
// Base结构体已经实现了接收者为实例的sleep()方法
// 那么可以在subA结构体实现 接收者为实例接受的run()方法即可---位于HERE处
//
i = a // A1 erro subA未实现接口,父类仅仅实现了sleep()方法,run()没有实现
i.run() // A1
i.sleep()
// b实例[字段指针继承]
b := subB{&base{}}
i = b // subB实现了接口
i.run() // B1
i.sleep()
// =======指针实例转换为接口==========
// 指针实例[字段继承]
pa := &subA{base{}}
i = pa // subA实现了接口
i.run() // C1
i.sleep()
// 指针实例[字段指针继承]
pb := &subB{&base{}}
i = pb // subB实现接口
i.run() // D1
i.sleep()
}
具体可查看