• go語言的面向物件相對簡單，只支援封裝，不支援繼承和多型，go中用面向介面來做繼承和多型的任務
• go中沒有class ,只有struct
• struct的建立

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

• struct的宣告和初始化

//宣告一個結構體型別
    var root treeNode
    
    //初始化方式一
    root = treeNode{value:3}

    //初始化方式二
    root.left = &treeNode{}
    root.right = &treeNode{5,nil,nil}

    //初始化方式三
    root.right.left = new(treeNode)   
    //new(),只接受一個引數，這個引數是一個型別，分配好記憶體後，返回一個指向該型別記憶體地址的指標。同時請注意它同時把分配的記憶體置為零，也就是型別的零值。
    //這裡，root結構本身，而root.left是一個地址，在go中不論地址含是結構本身，一律用＂．＂來訪問成員，　　而C++中，訪問地址的成員要用＂->＂

    //初始化方法四 使用工廠方法
    root.right.right = creatNode(4) 
    
    nodes := []treeNode{
        {value:3},          //這裡相當於 treeNode{value:3}, 前面的treeNode省略掉了

        {},
        {6,nil,&root},
    }    
    fmt.Println(nodes)   //輸出結果：　[{3 <nil> <nil>} {0 <nil> <nil>} {6 <nil> 0xc420090020}] 

• struct的工廠化方法，go的結構體沒有建構函式一說，但我們可以給我們定義的結構體建立一個工廠方法，用來初始化結構體
• 工廠方法返回了一個區域性變數地址

func creatNode(value int) *treeNode {
    return &treeNode{value: value}
    //這裡，treeNode{value: value}是定義在函式中的，若在Ｃ++中，它是一個區域性變數，是不能返回到外面給別人使用的，但在go中，區域性變數可以返回出去給別人使用

} 

• 為struct建立方法，＂func＂後可以跟一個接受者，其實這個接受者實質上也是函式的一個引數，只是呼叫的時候會有些區別

func (node treeNode) print() {
    fmt.Println(node.value)
}
其和　

func print(node treeNode) {
         fmt.Println(node.value)
 }
本質上實現的作用一樣
但前者的呼叫：　print(root)
後者的呼叫：　　root.print() 

• struct方法接收者的值傳遞和指標傳遞：
• 結構體方法的接受者，同樣是傳值的，想要傳遞引用，則宣告為指標型別
• 只有將接受者設為指標，才可改變結構體的內容

func (node treeNode) setValue1 (value int){　　//接收者為值傳遞
    node.value = value
}

func (node *treeNode) setValue2 (value int){　　//接收者為指標傳遞
    node.value = value
    //這裡的node是一個指標型別，是一個地址，go中地址也可以通過＂．＂來直接訪問其地址所存內容的成員，而不需(*node).value 或　node->value
}

結果驗證：

root.right.left.print()      //輸出結果：０
root.right.left.setValue1(10)
root.right.left.print()    //輸出結果：０　　setValue1（）為值傳遞，value沒有被改掉
    
root.right.left.setValue2(20)
root.right.left.print()     //輸出結果：2０　　setValue２（）引用傳遞，value被改掉

//注意：這裡在呼叫的時候，會進行人性化處理，接受者是結構指標型別或者是實際的結構型別，呼叫者是結構指標或實際結構體，不管如何組合都是可以混用的
 (*root.right.left).print()     //輸出結果：2０　與　root.right.left.print()　一致

• go中struct的接收者為nil指標時也可以呼叫方法
• go中的nil與其他語言中的null不同，null只是用來判斷是不是空

func (node *treeNode) setValue3 (value int){
    if node == nil{
        fmt.Println("setting value to nil node!")
        return
    }
    node.value = value
} 

結果驗證：

var pRoot *treeNode
pRoot.setValue3(30)   　　//輸出結果：setting value to nil node!
//這裡的pRoot 只有宣告　是一個nil指標，但它同樣可以呼叫setValue3()

• 值接收者VS指標接受者

1. 要改變內容必須使用指標接收者
2. 結構過大也考略使用指標接受者
3. 一致性:如有指標接受者，最好都是指標接收者
4. 值接收者是go語言特有的，其他語言都有指標接收者（Java中的this）
5. 值/指標接收者均可接收值/指標 
    

• struct是建立在堆上還是棧上？

1. c++中，區域性變數是分配在棧上的，函式一退出，區域性變數會立刻被銷燬，若想要傳出去，必須在堆上分配，堆上分配的要手動釋放
2. Java中多使用new(),使用new()是分配在堆上的，需要有垃圾回收機制
3. go中，不需要知道結構建立在哪裡，go語言的編譯器以及執行環境會根據需要自動檢測結構需要建立在哪裡，go中存在垃圾回收器，堆上分配的內容會參與垃圾回收 
    

• 樹的中序遍歷 

//構造一棵樹｀ 

var root treeNode
    root = treeNode{value:3}
    root.left = &treeNode{}
    root.right = &treeNode{5,nil,nil}
    root.right.left = new(treeNode)   
    root.right.right = creatNode(4)  

//中序遍歷整棵樹  左－中－右的順序
func (node *treeNode) traverse(){
    if node == nil{
        return
    }
    node.left.traverse()
    node.print()
    node.right.traverse()
} 

完整程式碼：

package main

import (
	"fmt"
)

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


//go的結構體沒有建構函式一說，但我們可以建立一個工廠方法給我們定義的結構體
//工廠方法返回了一個區域性變數地址
func creatNode(value int) *treeNode {
	return &treeNode{value: value}
	//這裡，treeNode{value: value}是定義在函式中的，若在Ｃ++中，它是一個區域性變數，是不能返回到外面給別人使用的，但在go中，區域性變數可以返回出去給別人使用
}



//為結構體建立方法，＂func＂後可以跟一個接受者，其實這個接受者實質上也是函式的一個引數，只是呼叫的時候會有些區別
func (node treeNode) print() {
	fmt.Println(node.value)
}
//其和　func print(node treeNode) {
//     	fmt.Println(node.value)
//     }
//本質上實現的作用一樣
//但前者的呼叫：　print(root)
//後者的呼叫：　　root.print()

//結構體方法的接受者，同樣是傳值的，想要傳遞引用，則宣告為指標型別
//只有將接受者設為指標，才可改變結構體的內容
func (node treeNode) setValue1 (value int){
	node.value = value
}
func (node *treeNode) setValue2 (value int){
	node.value = value
	//這裡的node是一個指標型別，是一個地址，go中地址也可以通過＂．＂來直接訪問其地址所存內容的成員，而不需(*node).value 或　node->value
}

//nil指標也可以呼叫方法
//go中的nil與其他語言中的null不同，null只是用來判斷是不是空
func (node *treeNode) setValue3 (value int){
	if node == nil{
		fmt.Println("setting value to nil node!")
		return
	}
	node.value = value
}


//中序遍歷整棵樹  左－中－右的順序
func (node *treeNode) traverse(){
	if node == nil{
		return
	}
	node.left.traverse()
	node.print()
	node.right.traverse()
}


func main() {
	//宣告一個結構體型別
	var root treeNode
	
	//初始化方式一
	root = treeNode{value:3}
	//初始化方式二
	root.left = &treeNode{}
	root.right = &treeNode{5,nil,nil}
	//初始化方式三
	root.right.left = new(treeNode)   
	//new(),只接受一個引數，這個引數是一個型別，分配好記憶體後，返回一個指向該型別記憶體地址的指標。同時請注意它同時把分配的記憶體置為零，也就是型別的零值。
	//這裡，root結構本身，而root.left是一個地址，在go中不論地址含是結構本身，一律用＂．＂來訪問成員，　　而C++中，訪問地址的成員要用＂->＂
	//初始化方法四 使用工廠方法
	root.right.right = creatNode(4) 
	
	nodes := []treeNode{
		{value:3},          //這裡相當於 treeNode{value:3}, 前面的treeNode省略掉了
		{},
		{6,nil,&root},
	}	
	fmt.Println(nodes)   //輸出結果：　[{3 <nil> <nil>} {0 <nil> <nil>} {6 <nil> 0xc420090020}]
	 
	root.print()    //輸出結果：　３
	
	root.right.left.print()      //輸出結果：０
	root.right.left.setValue1(10)
	root.right.left.print()    //輸出結果：０　　setValue1（）為值傳遞，value沒有被改掉
	
	root.right.left.setValue2(20)
	root.right.left.print()     //輸出結果：2０　　setValue２（）引用傳遞，value被改掉
	//這裡在呼叫的時候，會進行人性化處理，接受者是結構指標型別或者是實際的結構型別，呼叫者是結構指標或實際結構體，不管如何組合都是可以混用的
	(*root.right.left).print()     //輸出結果：2０
	
	
	var pRoot *treeNode
	pRoot.setValue3(30)   //輸出結果：setting value to nil node!
	//這裡的pRoot 只有宣告　是一個nil指標，但它同樣可以呼叫setValue3()
	
	root.traverse()  //輸出：０　３　２０　５　４
}