GO语言学习入门笔记系列详解(六)：Go语言的面向对象

GO语言学习入门笔记系列详解(六)：Go语言的面向对象

结构体和方法

• go语言仅支持封装，不支持继承和多态
• go语言没有class，只有struct

结构的定义

• 不论是地址还是结构体本身，一律使用.来访问成员

type treeNode struct {
	value       int
	left, right *treeNode
}

func main() {
	var root treeNode
	
	//初始化
	root = treeNode{value: 3}
	root.left = &treeNode{}
	root.right = &treeNode{5,nil,nil}
	root.right.left = new(treeNode)
}

• 使用自定义工厂函数
• 注意返回了局部变量的地址！

func creatNode(value int) *treeNode {
	return &treeNode{value:3}
}

• 为结构体定义方法
• 显示定义和命名方法接收者
• 只有使用指针才能改变结构体内容
• nil指针也可以调用方法

//print是给treeNode的调用
func (node treeNode) print() {
	fmt.Print(node.value)
}

func (node *treeNode) setValue(value int) {
	if node == nil{
		fmt.Printf("Setting value to nil" + "node.Ignored,")
		return
	}
	node.value = value
}

func createNode(value int) *treeNode {
	return &treeNode{value: value}
}

值接收者还是vs指针接收者

• 要改变必须使用指针接收者
• 结构过大也可以考虑使用指针
• 一致性：如有指针接收者，最好都是指针接收者
• 值接收者是goo语言特有的
• 值接收者/指针接收者均可以接收值/指针

包和封装

• 名字一般使用CamelCase
• 首字母大写：public
• 首字母小写：private

包

• 每个目录一个包
• main包包含可执行入口
• 为结构定义的方法必须放在同一个包内
• 可以是不同的文件

分包

1. 将main函数单独放到一个包中

package main

import tree "GoLearn/src/study01/test02"

func main() {
	var root tree.Node
	//初始化
	root = tree.Node{Value: 3}
	root.Left = &tree.Node{}
	root.Right = &tree.Node{5, nil, nil}
	root.Right.Left = new(tree.Node)
	root.Left.Right = tree.CreateNode(2)
	root.Right.Left.SetValue(4)

	root.Traverse()

}

2. tree包中的函数和结构体名字要改成大写

package tree

import "fmt"

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

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

// Print print是给treeNode的调用
func (node Node) Print() {
	fmt.Print(node.Value)
}

func (node *Node) SetValue(value int) {
	if node == nil {
		fmt.Printf("Setting value to nil" + "node.Ignored,")
		return
	}
	node.Value = value
}

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

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

扩展已有的类型

如何拓展系统类型或者别人的类型

使用组合

• myNode.node.Left的类型是tree.Node，不是myTreeNode。不包一下的话后续代码会编译错误

type myTreeNode struct {
	node *tree.Node
}

func (myNode *myTreeNode) postOrder() {
	if myNode == nil || myNode.node == nil {
		return
	}

	left := myTreeNode{myNode.node.Left}
	left.postOrder()
	right := myTreeNode{myNode.node.Right}
	right.postOrder()
	myNode.node.Print()
}

	myroot := myTreeNode{&root}
	myroot.postOrder()
	fmt.Println()

定义别名

package queue

type Queue []int

func (q *Queue) Push(v int) {
	*q = append(*q, v)
}

func (q *Queue) Pop() int {
	head := (*q)[0]
	*q = (*q)[1:]
	return head
}

func (q *Queue) IsEmpty() bool {
	return len(*q) == 0
}

package main

import (
	"GoLearn/src/study01/test02/queue"
	"fmt"
)

func main() {
	q := queue.Queue{1}
	q.Push(2)
	q.Push(3)

	fmt.Println(q.Pop())
	fmt.Println(q.Pop())
	fmt.Println(q.IsEmpty())
	fmt.Println(q.Pop())
	fmt.Println(q.IsEmpty())
}

使用内嵌类型扩展已有类型

• 第一次修改

type myTreeNode struct {
	*tree.Node //Embedding
}

func (myNode *myTreeNode) postOrder() {
	if myNode == nil || myNode.Node == nil {
		return
	}

	left := myTreeNode{myNode.Left}
	left.postOrder()
	right := myTreeNode{myNode.Right}
	right.postOrder()
	myNode.Print()
}

• 第二次修改main函数

	//初始化
	root := myTreeNode{&tree.Node{Value: 3}}
	root.Left = &tree.Node{}
	root.Right = &tree.Node{5, nil, nil}
	root.Right.Left = new(tree.Node)
	root.Left.Right = tree.CreateNode(2)
	root.Right.Left.SetValue(4)

	root.Traverse()
	fmt.Println()

	root.postOrder()
	fmt.Println()