Go語言開發（四）、Go語言面向對象

時間  2019-11-05
標籤 語言 開發 面向對象 欄目 軟件設計 简体版
原文   原文鏈接

Go語言開發（四）、Go語言面向對象

1、結構體和方法

一、結構體的定義

在結構體中能夠爲不一樣項定義不一樣的數據類型。
結構體是由一系列具備相同類型或不一樣類型的數據構成的數據集合。
結構體定義須要使用type和struct語句。struct語句定義一個新的數據類型，結構體有中有一個或多個成員。type語句設定告終構體的名稱。結構體的格式以下：node

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

結構體類型用於變量聲明的語法格式以下：
variable_name := structure_variable_type {value1, value2...valuen}
二叉樹節點的數據結構定義以下：git

package main

import "fmt"

type TreeNode struct{
   Value int
   Left,Right *TreeNode
}

func main() {
   var root TreeNode
   fmt.Println(root)
}

二、結構體成員的訪問

若是要訪問結構體成員，須要使用點號(.)操做符，格式爲："結構體.成員名"。
結構體類型變量使用struct關鍵字定義，實例以下：github

func main() {
   var root TreeNode
   root.Value = 0
   root.Left = &TreeNode{Value:1}
   root.Right = &TreeNode{2,nil,nil}
   root.Left.Left = &TreeNode{Value:3}
   root.Print()
}

三、結構體方法的定義

結構體方法定義在結構體做用域外，須要在函數聲明中指定接收者。windows

func (variable_name struct_variable_type) function_name(parameters){
    //函數體
}

如二叉樹節點的遍歷打印函數以下：數據結構

func (node TreeNode) Print(){
      fmt.Println(node.Value, " ")
}

func (node *TreeNode)traverse(){
   if node != nil{
      //遞歸遍歷左子樹
      node.Left.traverse()
      node.Print()
      //遞歸遍歷右子樹
      node.Right.traverse()
   }
}

四、結構體指針

若是結構體的方法中須要對結構體成員的值進行修改，必須使用結構體指針做爲方法的接收者。若是結構體過大也要考慮使用結構體指針做爲方法的接收者。值接收者和指針接收者均可以接收值、指針傳遞的結構體。
nil指針也能夠調用方法。ide

package main

import (
   "fmt"
)

type TreeNode struct{
   Value int
   Left,Right *TreeNode
}

func createTreeNode(value int) *TreeNode{
   return &TreeNode{Value:value}
}

func (node TreeNode) Print(){
      fmt.Println(node.Value, " ")
}

func (node *TreeNode)traverse(){
   if node != nil{
      //遞歸遍歷左子樹
      node.Left.traverse()
      node.Print()
      //遞歸遍歷右子樹
      node.Right.traverse()
   }
}

func (node *TreeNode)setValue(value int){
   if node!= nil{
      node.Value = value
   }else {
      fmt.Println("The node is nil.")
   }
}

func main() {
   var root TreeNode
   root.Value = 0
   root.Left = &TreeNode{Value:1}
   root.Right = &TreeNode{2,nil,nil}
   root.Left.Left = &TreeNode{Value:3}
   root.traverse()

   root.setValue(100)
   root.traverse()
   }

2、包和封裝

一、包簡介

包用於組織Go源代碼，提供了更好的可重用性與可讀性。因爲包提供了代碼的封裝，所以使得Go應用程序易於維護。
Go語言的面向對象只支持封裝，不支持繼承和多態。
Go語言使用CamelCase命名方法對函數進行命名，函數名稱的首字母大寫表示public，小寫表示private。
訪問權限是針對包的，Go語言中每一個目錄是一個包，包名與目錄名能夠不相同。若是目錄下有一個main函數，目錄只能有一個main包，main包包含可執行入口。
爲結構體定義的方法必須在一個包內，但能夠是不一樣的文件。函數

二、包的定義

全部可執行的Go程序都必須包含一個main函數，做爲程序運行的入口。main函數應該放置於main包中。
包的定義語法以下：
package packagename
指定某一源文件屬於一個包，應該放在每個源文件的第一行。
導入一個已存在的包的語法以下：
import "packagename" 
屬於某一個包的源文件都應該放置於一個單獨命名的文件夾裏。按照Go語言的慣例，應該用包名命名包的文件夾。
在packagename文件夾中，全部文件都會以package packagename做爲開頭，由於文件夾中全部文件Go語言文件都屬於packagename包。工具

三、包的導入

爲了使用自定義包，必需要先導入包。導入自定義包的語法爲import path。必須指定自定義包相對於工做區內 src 文件夾的相對路徑。
Go語言中導入了包，卻不在代碼中使用包，是非法的。在程序開發階段，經常會先導入包，而暫不使用，可使用空白標識符 。
var = packagename.method代碼能夠屏蔽錯誤。
若是導入一個包，只爲了確保包進行了初始化，而無需使用包中的任何函數或變量，如須要確保調用包的init函數，而不須要在代碼中使用包，可使用空白標識符。
import (_ "packagename")
在使用import導入包的時候，若是發生包命名衝突，能夠在import的名稱前面加一個包的別名處理。使用方法以下：
import (packageAnotherName "packagename")post

四、init函數

全部包均可以包含一個init函數。init函數不該該有任何返回值類型和參數，在用戶代碼中也不能顯式地調用。init函數的形式以下：
func init() { }
init函數可用於執行初始化任務，也可用於在開始執行前驗證程序的正確性。
包的初始化順序以下：
A、首先初始化包級別（Package Level）的變量
B、緊接着調用init函數。包能夠有多個init函數（在一個文件或分佈於多個文件中），按照編譯器解析的順序進行調用。
C、若是一個包導入另外一個包，會最早初始化被導入的包。
D、一個包能夠被導入屢次，但只會被初始化一次。
main包的初始化順序爲：
A、首先初始化被導入的包。
B、接着初始化包級別的變量。
C、調用main包的init函數。
D、最後調用main函數。ui

3、擴展已有類型

Go語言中使用定義別名和組合來擴展已有的類型。

一、使用組合擴展

能夠經過定義一個新的類型，內部組合了要擴展類型的對象對已有類型進行擴展。如對TreeNode類型進行擴展，增長一個後序遍歷的方法。

//使用組合擴展TreeNode類型
type BinTreeNode struct{
   node *TreeNode
}
//BinTreeNode的方法
func (binTreeNode *BinTreeNode)postOrderTraverse(){
   if binTreeNode != nil && binTreeNode.node != nil{
      left := BinTreeNode{binTreeNode.node.Right}
      left.postOrderTraverse()
      right := BinTreeNode{binTreeNode.node.Left}
      right.postOrderTraverse()
      node := binTreeNode.node
      node.Print()
   }
}

二、使用別名擴展

能夠對已有類型定義一個別名，經過對別名類型增長新的方法實現對已有類型的擴展。

//定義TreeNode的別名
type PreOrderTreeNode TreeNode

//定義PreOrderTreeNode類型的方法
func (pNode *PreOrderTreeNode)preOrderTraverse(){
   if pNode != nil{
      node := (*TreeNode)(pNode)
      node.Print()
      //打印左子樹
      left := (*PreOrderTreeNode)(pNode.Left)
      left.preOrderTraverse()
      //打印右子樹
      right := (*PreOrderTreeNode)(pNode.Right)
      right.preOrderTraverse()
   }
}

三、程序實例

package main

import (
   "fmt"
)

type TreeNode struct{
   Value int
   Left,Right *TreeNode
}

func createTreeNode(value int) *TreeNode{
   return &TreeNode{Value:value}
}

func (node TreeNode) Print(){
      fmt.Println(node.Value, " ")
}

func (node *TreeNode)traverse(){
   if node != nil{
      //遞歸遍歷左子樹
      node.Left.traverse()
      node.Print()
      //遞歸遍歷右子樹
      node.Right.traverse()
   }
}

func (node *TreeNode)setValue(value int){
   if node!= nil{
      node.Value = value
   }else {
      fmt.Println("The node is nil.")
   }
}

//使用組合擴展TreeNode類型
type PostOderTreeNode struct{
   node *TreeNode
}
//BinTreeNode的方法
func (binTreeNode *PostOderTreeNode)postOrderTraverse(){
   if binTreeNode != nil && binTreeNode.node != nil{
      left := PostOderTreeNode{binTreeNode.node.Right}
      left.postOrderTraverse()
      right := PostOderTreeNode{binTreeNode.node.Left}
      right.postOrderTraverse()
      node := binTreeNode.node
      node.Print()
   }
}

//定義TreeNode的別名
type PreOrderTreeNode TreeNode

//定義PreOrderTreeNode類型的方法
func (pNode *PreOrderTreeNode)preOrderTraverse(){
   if pNode != nil{
      node := (*TreeNode)(pNode)
      node.Print()
      //打印左子樹
      left := (*PreOrderTreeNode)(pNode.Left)
      left.preOrderTraverse()
      //打印右子樹
      right := (*PreOrderTreeNode)(pNode.Right)
      right.preOrderTraverse()
   }
}

func main() {
   var root TreeNode
   root.Value = 0
   root.Left = &TreeNode{Value:1}
   root.Right = &TreeNode{2,nil,nil}
   root.Left.Left = &TreeNode{Value:3}
   root.traverse()

   root.setValue(100)
   root.traverse()
   fmt.Println()
   rootItem1 := PostOderTreeNode{&root}
   rootItem1.postOrderTraverse()
   fmt.Println()
   rootItem2 := (PreOrderTreeNode)(root)
   rootItem2.preOrderTraverse()
}

4、GO環境變量

一、GOROOT

GOROOT環境變量是go的安裝路徑。

GOROOT=/usr/local/go
export GOROOT

要執行go命令和go工具, 須要配置go的可執行文件的路徑:
export $PATH:$GOROOT/bin
若是是windows須要使用;符號分割兩個路徑, mac和類unix使用:符號分割。

二、GOPATH

go install/go get和 go的工具等會用到GOPATH環境變量。
GOPATH是Go語言開發的工做空間，做爲編譯後二進制的存放目的地和import包時的搜索路徑。
GOPATH表示代碼包所在的地址，能夠設置多個。
GOPATH環境變量默認在當前用戶主目錄下的go目錄，全部項目和第三方庫都放在同一個GOPATH下。
GOPATH用來存放Go源碼，Go的可運行文件，以及相應的編譯以後的包文件。因此這個目錄下面有三個子目錄：src、bin、pkg
GOPATH容許多個目錄，當有多個目錄時，請注意分隔符，多個目錄的時候Windows是分號，Linux系統是冒號，當有多個GOPATH時，默認會將 go get 的內容放在第一個目錄下。
$GOPATH 目錄約定有三個子目錄：
A、src目錄存放源代碼（好比：.go .c .h .s等）
B、pkg目錄存放編譯後生成的package（好比：.a）
C、bin目錄存放編譯後生成的可執行文件
不能把GOPATH設置成go的安裝路徑，能夠本身在用戶目錄下建立一個目錄, 如go。

GOPATH=/home/user/go:/home/user/dev
export GOPATH

爲了使用方便，一般須要將全部工做空間的bin路徑添加到PATH環境變量中，如：
export $PATH:$GOPATH/bin
若是$GOPATH有多個工做目錄，使用 ${GOPATH//://bin:}/bin 添加全部的bin目錄。
export $PATH:${GOPATH//://bin:}/bin
GOPATH有兩個目錄（一個用於存放第三方包，一個用戶開發），若是使用 go工具進行第三方包的安裝，默認會安裝到第一個目錄 (/home/user/go)，若是在/home/user/dev中寫代碼，使用g工具(go install, go build) 會將二進制包安裝到/home/user/dev中。
GOPATH設置兩個目錄的優勢在於第一個目錄做爲第三方包的存放位置，第二個目錄做爲開發者本身的工做空間。第三方的GOPATH放置到第一位，go 安裝工具會將其做爲默認的位置。
當使用go命令搜索包時，首先搜索 $GOROOT路徑，而後是$GOPATH/src路徑。

三、遠程包

go語言有一個獲取遠程包的工具就是go get，目前go get支持多數開源社區(例如：github、googlecode、bitbucket、Launchpad)。
go get github.com/xxx/xxx
go get -u 參數能夠自動更新包，並且當go get的時候會自動獲取該包依賴的其它第三方包，默認會安裝到$GOPATH的第一個目錄。
在代碼中使用遠程包與使用本地包同樣。
import "github.com/xxx/xxx"

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程