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

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的原创作品，如需转载，请注明出处，否则将追究法律责任