go语法--基础27--面向对象--扩展已有的类型

一、扩展已有的类型

1.1、使用组合

举例:别人的包只有打印最左边的节点，而我们的需求是要打印最右边的节点

别人的代码

package tree

import "fmt"

//定义结构
type TreeNode struct {
	Value       int
	Left, Right *TreeNode
}

//打印左边的节点
func PrintFirstNode(node TreeNode) {

	leftNode := node.Left
	if (leftNode != nil) {
		PrintFirstNode(*leftNode)
	} else {
		fmt.Println("treeNode:", node.Value)
	}
}

扩展的代码

package myTree

import (
	"day02/tree"
	"fmt"
)

//定义结构
type MyTreeNode struct {
	TreeNode *tree.TreeNode
}

//打印最右边的节点
func PrintLastNode(myTreeNode MyTreeNode) {

	node := myTreeNode.TreeNode
	if (node == nil) {
		return
	}

	treeNode1 := node.Right

	if (treeNode1 == nil) {
		fmt.Println("treeNode:", node.Value)
	}

	PrintLastNode(MyTreeNode{TreeNode: treeNode1})

}


-------------------------

package main

import (
	"day02/my"
	"day02/tree"
	"fmt"
)

func main() {
	// 构建 1,2,3,4,5 的节点
	var root tree.TreeNode
	root = tree.TreeNode{3, nil, nil}
	root.Left = &tree.TreeNode{2, nil, nil}
	root.Left.Left = &tree.TreeNode{1, nil, nil}

	root.Right = &tree.TreeNode{4, nil, nil}
	root.Right.Right = &tree.TreeNode{5, nil, nil}

	fmt.Println("---------打印最左节点---------");
	tree.PrintFirstNode(root);
	fmt.Println("---------打印最右节点---------");
	myTreeNode := myTree.MyTreeNode{&root}
	myTree.PrintLastNode(myTreeNode)

}

1.2、使用别名

使用编码代码

package myTree

import (
	"day02/tree"
	"fmt"
)

//使用别名对已有类型进行扩展　用别名＂MyTreeNode2＂扩展原类型 tree.TreeNode，为其增加 打印最右边的节点  方法
type MyTreeNode2 *tree.TreeNode;

//打印最右边的节点
func PrintLastNode2(myTreeNode2 MyTreeNode2) {

	if (myTreeNode2 == nil) {
		return
	}

	node := myTreeNode2.Right

	if (node == nil) {
		fmt.Println("treeNode:", myTreeNode2.Value)
		return
	}

	PrintLastNode2(node)

}
------

package main

import (
	"day02/my"
	"day02/tree"
	"fmt"
)

func main() {
	// 构建 1,2,3,4,5 的节点
	var root tree.TreeNode
	root = tree.TreeNode{3, nil, nil}
	root.Left = &tree.TreeNode{2, nil, nil}
	root.Left.Left = &tree.TreeNode{1, nil, nil}

	root.Right = &tree.TreeNode{4, nil, nil}
	root.Right.Right = &tree.TreeNode{5, nil, nil}

	//fmt.Println("---------打印最左节点---------");
	//tree.PrintFirstNode(root);
	//fmt.Println("---------打印最右节点---------");
	//myTreeNode := myTree.MyTreeNode{&root}
	//myTree.PrintLastNode(myTreeNode)

	fmt.Println("---------打印最右节点2---------");
	var myTreeNode2 myTree.MyTreeNode2 = &root
	myTree.PrintLastNode2(myTreeNode2)
}

---

1.3、 使用内嵌来扩展已有类型

package myTree

import (
	"fmt"
	"go-learn-02/day02/tree"
)

//定义结构
type MyTreeNode3 struct {
	//使用内嵌
	*tree.TreeNode
}

//打印最右边的节点
func PrintLastNode3(myTreeNode MyTreeNode3) {

	if myTreeNode.TreeNode == nil {
		return
	}

	//直接使用内嵌对象的函数

	if myTreeNode.Right == nil {
		fmt.Println("treeNode:", myTreeNode.Value)
	}

	PrintLastNode3(MyTreeNode3{myTreeNode.Right})

}
---------

package main

import (
	"fmt"
	myTree "go-learn-02/day02/my"
	"go-learn-02/day02/tree"
)

func main() {
	// 构建 1,2,3,4,5 的节点
	var root tree.TreeNode
	root = tree.TreeNode{3, nil, nil}
	root.Left = &tree.TreeNode{2, nil, nil}
	root.Left.Left = &tree.TreeNode{1, nil, nil}

	root.Right = &tree.TreeNode{4, nil, nil}
	root.Right.Right = &tree.TreeNode{5, nil, nil}

 
	fmt.Println("---------打印最右节点3---------")

	var myTreeNode3 = myTree.MyTreeNode3{&root}
	myTree.PrintLastNode3(myTreeNode3)

}
输出
---------打印最右节点3---------
treeNode: 5