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)
}

对于类方法，指针和值传递编译器可以自行转换，但对于非类方法，只能自己转换。

只有指针传递才能改变类属性值。

类方法和属性大小表示可以被外部调用。