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"
原文地址：http://blog.51cto.com/9291927/2130132