Go学习:使用内嵌来扩展已有类型

如何扩充已有类型?

• 定义别名:最简单,但是由于以后的维护可能会改成使用组合,别名到组合不能无缝转换;需要改很多代码
• 使用组合:最常用
• 使用内嵌:需要省下很多代码;但是可读性较差

定义别名&使用组合

https://blog.csdn.net/qq_43135259/article/details/123194344?spm=1001.2014.3001.5502

使用内嵌

node

package tree

import "fmt"

type Node struct {
	Value       int
	Left, Right *Node
}

func CreateNode(value int) *Node {
	return &Node{Value: value}
}

func (node *Node) Print() {
	fmt.Print(node.Value, " ")
}

func (node *Node) SetValue(value int) {
	if node == nil {
		fmt.Println("node is nil")
		return
	}
	node.Value = value
}

traversesal

package tree

func (node *Node) Traverse() {
	if node == nil {
		return
	}
	node.Left.Traverse()
	node.Print()
	node.Right.Traverse()
}

entry

package main

import (
	"awesomeProject/tree"
	"fmt"
)

type myNode struct {
	*tree.Node
}

func (node *myNode) postOrder() {
	if node == nil || node.Node == nil {
		return
	}
	left := myNode{node.Left}
	left.postOrder()
	right := myNode{node.Right}
	right.postOrder()
	node.Print()
}

func (node *myNode)Traverse(){
	fmt.Println("Go to Shadowed Methods")
}

func main() {

	root := myNode{ &tree.Node{Value: 3}}
	root.Left = &tree.Node{}
	root.Right = &tree.Node{Value: 5}
	root.Right.Left = new(tree.Node)
	root.Left.Right = tree.CreateNode(2)
	root.Right.Left.SetValue(4)

	// Go to Shadowed Methods
	root.Traverse()
	// 0 2 3 4 5
	root.Node.Traverse()
	fmt.Println()


	// 2 0 4 5 3
	myRoot := myNode{ root.Node}
	myRoot.postOrder()

	// cannot use &root (type *myNode) as type tree.Node in assignment
	var baseRoot tree.Node
	baseRoot = &root
}

• 内嵌的话就是把tree.Node的属性名给删掉了;但其实还有一个默认的属性名,就是这个struct的名字:Node
• myNode 里面内嵌了一个tree.Node;这样的话myNode就可以使用tree.Node的所有成员变量与方法,同样的还可以使用自己的其他成员变量与方法
• myNode可以对tree.Node的方法进行重载;不过go不叫Override,叫Shadowed;myNode调用方法时,会先检查一下自己有没有这个方法,如果有就用自己的,如果没有就用tree.Node
• 内嵌看起来有点像继承,但是它与继承时完全不同的两个概念,继承的话可以父类引用指向子类对象;但是go语言却不支持;对编译器来说是没有审核联系的.内嵌的本质其实就是组合的语法糖