一. 结构体和方法
- go语言仅继承封装， 不支持继承和多态
- go语言没有class， 只有struct
使用指针作为方法接收者
func (node *TreeNode) setValue(value int) {
node.Value
}
// 只有使用指针才可以改变结构体内容
// nill指针也可以调用方法
值接收者VS指针接收者
- 要改变内容必须使用指针接收者
- 结构过大也考虑使用指针接收者
- 一致性： 如果有指针接收者， 最好都是指针接收者
- 值接收者 是go语言特有
- 值/指针接收者均可接收值/指针
代码举例
package main
import "fmt"
type Node struct {
Value int
Left, Right *Node
}
func (node Node) Print() { // 为struct 定义方法 传值方法
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 { // 工厂函数
return &Node{Value: value} // go语言可以返回局部变量的 地址
}
func main() {
var root Node
// 结构体的创建
// 不论地址还是结构本身， 一律使用 . 来访问成员
//建立这样一棵树
// 3
// / \
// 0 5
// \ /
// 2 0
root = Node{Value: 3}
root.Left = &Node{}
root.Right = &Node{5, nil, nil}
root.Right.Left = new(Node)
root.Left.Right = CreateNode(2)
// 使用struct的方法
root.Print() // 会把root 值传给print
root.Right.Left.SetValue(4) // 会把root.Right.Left的指针传给setvalue
proot := &root
proot.Print() // go会自动 变化指针和值， 找出合适的给方法， 所以在调用方法时， 无所谓指针还是值
// nodes := []Node{
// {Value: 3},
// {},
// {6, nil, &root},
// }
// fmt.Println(nodes)
}
包和封装
封装
- 名字一般使用CamelCase (驼峰)
- 首字母大写 表示： public
- 首字母小写 表示： private
- public和private 是针对包来说的
包
- 每个目录一个包
- main包 包含可执行入口
- 为结构定义的方法必须放在同一个包内
- 但可以是不同的文件
实际例子
- 目录结构
└── tree
├── node.go
├── traversal.go
└── treeentry
└── entry.go
// node.go 和 traversal.go 都是tree包的， 可以同时放在tree目录下
// entry.go 是 main包的， 所以要新建treeentry目录， 并放入其中
// 属于包tree中的方法想要在entry.go中使用， 命名时， 首字母大写
- node.go
package tree
import "fmt"
type Node struct {
Value int
Left, Right *Node
}
func (node Node) Print() { // 为struct 定义方法 传值方法
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 { // 工厂函数
return &Node{Value: value} // go语言可以返回局部变量的 地址
}
- 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)
}
func (node *Node) TraverseWithChannel() chan *Node {
out := make(chan *Node)
go func() {
node.TraverseFunc(func(node *Node) {
out <- node
})
close(out)
}()
return out
}
- entry.go
package main
import (
"fmt"
"learngo/lang/tree"
)
type myTreeNode struct {
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
// 结构体的创建
// 不论地址还是结构本身， 一律使用 . 来访问成员
//建立这样一棵树
// 3
// / \
// 0 5
// \ /
// 2 4
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) // go会自动 变化指针和值， 找出合适的给方法， 所以在调用方法时， 无所谓指针还是值
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)
c := root.TraverseWithChannel()
maxNodeValue := 0
for node := range c {
if node.Value > maxNodeValue {
maxNodeValue = node.Value
}
}
fmt.Println("Max node value:", maxNodeValue)
}
三. 拓展已有类型
如何扩充系统类型或者别人的类型
- 定义别名
package queue
// A FIFO queue.
type Queue []int // 定义别名
// Pushes the element into the queue.
// e.g. q.Push(123)
func (q *Queue) Push(v int) {
*q = append(*q, v)
}
// Pops element from head.
func (q *Queue) Pop() int {
head := (*q)[0]
*q = (*q)[1:]
return head
}
// Returns if the queue is empty or not.
func (q *Queue) IsEmpty() bool {
return len(*q) == 0
}
func ExampleQueue_Pop() {
q := 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())
// Output:
// 1
// 2
// false
// 3
// true
}
- 使用组合
entry.go
package main
import (
"fmt"
"learngo/lang/tree"
)
type myTreeNode struct { // 引入之后， 使用组合
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()
}
四. GOPATH环境变量
安装第三方库
- go get获取第三方库
- 使用gopm来获取无法下载的包
- go build 来编译
- go install 产生pkg 文件和可执行文件(会被丢入bin目录)
- go run 直接编译运行
GOPATH下目录结构
-
src
- git repository 1
- git repository 2
-
pkg
- git repository 1
- git repository 2
-
bin
- 可执行文件 1， 2， 3...