golang 面向對象 包管理

一、包管理

1、GOPATH

      ---bin

      ---pkg

      ---src

               ---learn

                         ---entry.go(package main)

                         ---tree

                               ---node.go(package node)

                               ---traversal.go(package node)

go get install XXX 會自動在GOPATH目錄生成bin/pkg/src目錄。

bin保存編譯後的文件(go install)，pkg保存是編譯中間文件，src保存的源碼。

進入到src/learn，使用go run entry.go可以運行go程序，但不生成bin文件。

使用go build entry.go，可以在當前目錄生成entry可執行文件，但不保存在GOPATH/bin目錄。

一個文件夾只能有一個包package，一個package可以有多個文件來定義，如node.go和traversal.go。

 

二、源碼

entry.go

package main

import (
	"fmt"
	"learn/tree"
)

type myTreeNode struct {//是爲了擴展tree.Node的功能
	node *tree.Node
}

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

	left := myTreeNode{myNode.node.Left}
	right := myTreeNode{myNode.node.Right}

	left.postOrder()
	right.postOrder()
	myNode.node.Print()
}

func main() {
	var root tree.Node

	root = tree.Node{Value: 3}
	root.SetValue(6)//值傳遞自動轉換指針傳遞
	root.Left = &tree.Node{}//Value:0
	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.Right.Left.Print()//指針傳遞轉換爲值傳遞
    tree.Print1(*root.Right.Left)//普通方法，沒有自動轉換，只能自己轉換

	fmt.Print("In-order traversal: ")
	root.Traverse()

	fmt.Print("My own post-order traversal: ")
	myRoot := myTreeNode{&root}
	myRoot.postOrder()
	fmt.Println()

	nodeCount := 0
	root.TraverseFunc(func(node *tree.Node) {//匿名函數
		nodeCount++
	})
	fmt.Println("Node count:", nodeCount)
}

node.go

package tree

import "fmt"

type Node struct { //定義類
	Value       int //大小代表root = tree.Node{Value: 3}可以這樣生成對象
	Left, Right *Node
}

func (node Node) Print() {//實現類方法 大小代表可以外部調用
	fmt.Print(node.Value, " ")
}

func Print1(node Node) { //不是類方法，普通方法
    fmt.Print(node.Value, " ")
}

func (node *Node) SetValue(value int) {//只有指針傳遞才能改變值
	if node == nil {
		fmt.Println("Setting Value to nil " +
			"node. Ignored.")
		return
	}
	node.Value = value
}

func CreateNode(value int) *Node {//無需關心C++局部變量的疑惑
	return &Node{Value: value}
}

traversal.go

package tree

import "fmt"

func (node *Node) Traverse() {
	node.TraverseFunc(func(n *Node) {
		n.Print()
	})
	fmt.Println()
}

func (node *Node) TraverseFunc(f func(*Node)) {
	if node == nil {
		return
	}

	node.Left.TraverseFunc(f)
	f(node)
	node.Right.TraverseFunc(f)
}

對於類方法，指針和值傳遞編譯器可以自行轉換，但對於非類方法，只能自己轉換。

只有指針傳遞才能改變類屬性值。

類方法和屬性大小表示可以被外部調用。