go语言开发（四）、go语言面向对象

一、结构体和方法

1、结构体的定义

在结构体中可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体定义需要使用type和struct语句。struct语句定义一个新的数据类型，结构体有中有一个或多个成员。type语句设定了结构体的名称。结构体的格式如下：

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

结构体类型用于变量声明的语法格式如下：
variable_name := structure_variable_type {value1, value2...valuen}
二叉树节点的数据结构定义如下：

package main

import "fmt"

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

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

2、结构体成员的访问

如果要访问结构体成员，需要使用点号(.)操作符，格式为：”结构体.成员名”。
结构体类型变量使用struct关键字定义，实例如下：

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

3、结构体方法的定义

结构体方法定义在结构体作用域外，需要在函数声明中指定接收者。

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

4、结构体指针

如果结构体的方法中需要对结构体成员的值进行修改，必须使用结构体指针作为方法的接收者。如果结构体过大也要考虑使用结构体指针作为方法的接收者。值接收者和指针接收者都可以接收值、指针传递的结构体。
nil指针也可以调用方法。

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

二、包和封装

1、包简介

包用于组织Go源代码，提供了更好的可重用性与可读性。由于包提供了代码的封装，因此使得Go应用程序易于维护。
Go语言的面向对象只支持封装，不支持继承和多态。
Go语言使用CamelCase命名方法对函数进行命名，函数名称的首字母大写表示public，小写表示private。
访问权限是针对包的，Go语言中每个目录是一个包，包名与目录名可以不相同。如果目录下有一个main函数，目录只能有一个main包，main包包含可执行入口。
为结构体定义的方法必须在一个包内，但可以是不同的文件。

2、包的定义

所有可执行的Go程序都必须包含一个main函数，作为程序运行的入口。main函数应该放置于main包中。
包的定义语法如下：
package packagename
指定某一源文件属于一个包，应该放在每一个源文件的第一行。
导入一个已存在的包的语法如下：
import "packagename" 
属于某一个包的源文件都应该放置于一个单独命名的文件夹里。按照Go语言的惯例，应该用包名命名包的文件夹。
在packagename文件夹中，所有文件都会以package packagename作为开头，因为文件夹中所有文件Go语言文件都属于packagename包。

3、包的导入

为了使用自定义包，必须要先导入包。导入自定义包的语法为import path。必须指定自定义包相对于工作区内 src 文件夹的相对路径。
Go语言中导入了包，却不在代码中使用包，是非法的。在程序开发阶段，常常会先导入包，而暂不使用，可以使用空白标识符 。
var = packagename.method代码可以屏蔽错误。
如果导入一个包，只为了确保包进行了初始化，而无需使用包中的任何函数或变量，如需要确保调用包的init函数，而不需要在代码中使用包，可以使用空白标识符。
import (_ "packagename")
在使用import导入包的时候，如果发生包命名冲突，可以在import的名称前面加一个包的别名处理。使用方法如下：
import (packageAnotherName "packagename")

4、init函数

所有包都可以包含一个init函数。init函数不应该有任何返回值类型和参数，在用户代码中也不能显式地调用。init函数的形式如下：
func init() { }
init函数可用于执行初始化任务，也可用于在开始执行前验证程序的正确性。
包的初始化顺序如下：
A、首先初始化包级别（Package Level）的变量
B、紧接着调用init函数。包可以有多个init函数（在一个文件或分布于多个文件中），按照编译器解析的顺序进行调用。
C、如果一个包导入另一个包，会最先初始化被导入的包。
D、一个包可以被导入多次，但只会被初始化一次。
main包的初始化顺序为：
A、首先初始化被导入的包。
B、接着初始化包级别的变量。
C、调用main包的init函数。
D、最后调用main函数。

三、扩展已有类型

Go语言中使用定义别名和组合来扩展已有的类型。

1、使用组合扩展

可以通过定义一个新的类型，内部组合了要扩展类型的对象对已有类型进行扩展。如对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()
   }
}

2、使用别名扩展

可以对已有类型定义一个别名，通过对别名类型增加新的方法实现对已有类型的扩展。

//定义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()
   }
}

3、程序实例

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

四、GO环境变量

1、GOROOT

GOROOT环境变量是go的安装路径。

GOROOT=/usr/local/go
export GOROOT

要执行go命令和go工具, 需要配置go的可执行文件的路径:
export $PATH:$GOROOT/bin
如果是windows需要使用;符号分割两个路径, mac和类unix使用:符号分割。

2、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路径。

3、远程包

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"

转自51CTO博客作者天山老妖S的原创作品