概述

  • 面向对象
    • go语句仅支持分装，不支持4继承和多态。 面向接口编程
    • go语言没有class 只有struct
  • 指针接收者与针接收者的选择
    • 要改变内容必须使用指针接收者
    • 结构过大也考虑使用指针接收者
    • 一致性：如有指针接收者，最好都是指针接收者
  • 封装
    • 名字一般使用CamelCase
    • 首字母大写: public
    • 首字母小写: private
  • 包
    • 每个目录一个包
    • main包包含执行入口
    • 为结构定义的方法必须放在同一个包内
    • 可以是不同的文件
  • 如何扩充系统类型或者别人的类型
    • 定义别名
    • 使用组合

代码

treeentry\entry.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "golearn/tree"
  6. )
  8. type myTreeNode struct {
  9.     node *tree.Node
  10. }
  12. func (myNode *myTreeNode) postOrder() {
  13.     if myNode == nil || myNode.node == nil {
  14.         return
  15.     }
  17.     left := myTreeNode{myNode.node.Left}
  18.     right := myTreeNode{myNode.node.Right}
  20.     left.postOrder()
  21.     right.postOrder()
  22.     myNode.node.Print()
  23. }
  25. func main() {
  26.     var root tree.Node
  28.     root = tree.Node{Value: 3}
  29.     root.Left = &tree.Node{}
  30.     root.Right = &tree.Node{5, nil, nil}
  31.     root.Right.Left = new(tree.Node)
  32.     root.Left.Right = tree.CreateNode(2)
  33.     root.Right.Left.SetValue(4)
  35.     fmt.Print("In-order traversal: ")
  36.     root.Traverse()
  38.     fmt.Print("My own post-order traversal: ")
  39.     myRoot := myTreeNode{&root}
  40.     myRoot.postOrder()
  41.     fmt.Println()
  43.     nodeCount := 0
  44.     root.TraverseFunc(func(node *tree.Node) {
  45.         nodeCount++
  46.     })
  47.     fmt.Println("Node count:", nodeCount)
  49.     c := root.TraverseWithChannel()
  50.     maxNodeValue := 0
  51.     for node := range c {
  52.         if node.Value > maxNodeValue {
  53.             maxNodeValue = node.Value
  54.         }
  55.     }
  56.     fmt.Println("Max node value:", maxNodeValue)
  57. }

node.go

  1. package tree
  3. import "fmt"
  5. type Node struct {
  6.     Value       int
  7.     Left, Right *Node
  8. }
  10. func (node Node) Print() {
  11.     fmt.Print(node.Value, " ")
  12. }
  14. func (node *Node) SetValue(value int) {
  15.     if node == nil {
  16.         fmt.Println("Setting Value to nil " +
  17.             "node. Ignored.")
  18.         return
  19.     }
  20.     node.Value = value
  21. }
  23. func CreateNode(value int) *Node {
  24.     return &Node{Value: value}
  25. }

traversal.go

  1. package tree
  3. import "fmt"
  5. func (node *Node) Traverse() {
  6.     node.TraverseFunc(func(n *Node) {
  7.         n.Print()
  8.     })
  9.     fmt.Println()
  10. }
  12. func (node *Node) TraverseFunc(f func(*Node)) {
  13.     if node == nil {
  14.         return
  15.     }
  17.     node.Left.TraverseFunc(f)
  18.     f(node)
  19.     node.Right.TraverseFunc(f)
  20. }
  22. func (node *Node) TraverseWithChannel() chan *Node {
  23.     out := make(chan *Node)
  24.     go func() {
  25.         node.TraverseFunc(func(node *Node) {
  26.             out <- node
  27.         })
  28.         close(out)
  29.     }()
  30.     return out
  31. }

封装

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

定义别名

  1. package queue
  3. // A FIFO queue.
  4. type Queue []int
  6. // Pushes the element into the queue.
  7. //         e.g. q.Push(123)
  8. func (q *Queue) Push(v int) {
  9.     *q = append(*q, v)
  10. }
  12. // Pops element from head.
  13. func (q *Queue) Pop() int {
  14.     head := (*q)[0]
  15.     *q = (*q)[1:]
  16.     return head
  17. }
  19. // Returns if the queue is empty or not.
  20. func (q *Queue) IsEmpty() bool {
  21.     return len(*q) == 0
  22. }
  1. package main
  3. import (
  4.     "fmt"
  5.     "golearn/queue"
  6. )
  8. func main() {
  9.     q := queue.Queue{1}
  11.     q.Push(2)
  12.     q.Push(3)
  13.     fmt.Println(q.Pop())
  14.     fmt.Println(q.Pop())
  15.     fmt.Println(q.IsEmpty())
  16.     fmt.Println(q.Pop())
  17.     fmt.Println(q.IsEmpty())
  18. }

image.jpeg