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教程