给Java程序员的Golang教程

╰半夏微凉° 2023-10-02 12:34 6阅读 0赞

## Go与Java ##

### 零.GoApi文档和中文社区网址 ###

Go的中文api文档：https://studygolang.com/pkgdoc

Go中文社区网站：https://studygolang.com/

### 一.关于Java ###

#### 1.Java的用途 ####

首先我们来回顾下Java的主要用途和应用场景：

用途一：服务器后端系统开发(web后端、微服务后端支付系统、业务系统、管理后台，各种后台交互的接口服务)。
     	
     	用途二：大数据框架的底层实现和Java的API支持。(Hadoop)。
    
    	用途三：其它中间件的底层开发。(Tomcat、RocketMq、Hbase、Kafka(部分)、SpringCloud，Dubbo...)。

#### 2.Java的优势和特点 ####

那我们看Java语言有什么优势和特点呢？

*.做服务端系统性能高。
    
    	*.有虚拟机，跨平台。
    
    	*.功能强大，支持的类库多，生态圈类库多，开发框架和工具更易找。
    
    	*.市场占有率高，约60%的中国程序员都是做Java相关的工作。

### 二.关于Go ###

#### 1.Go的出生原因 ####

Go语言是Google内部公司大佬开发的，主要起因于Google公司有大量的C程序项目，但是开发起来效率太低，维护成本高，于是就开发了Go语言来提高效率，而且性能只是差一点。
    
    （Go是2007年开始研发，2009推出发布）

#### 2.宏观看Go与Java的差异 ####

接着，我们来看一下Go语言与Java的差异之处：

*.无虚拟机，不跨平台(这里的平台指操作系统)(可以运行多个平台，每个平台打不同的二进制程序包)，需要打包编译成对应服务器操作系统版本(windows/linux)的可执行程序(比如windows是exe)。(注:说go跨平台的是指32位和64位相同操作系统之间的跨平台)
    
    	*.因为Go程序直接打包成操作系统可执行的文件，没有虚拟机在中间转换的一层，所以理论上执行效率会更高（理论上更高，实际情况需具体分析)。
    
    	*.相比Java的语言和代码编写风格，Go更简洁，可以用更少的代码实现同样的功能。
    
    	*.Go语言底层也是C实现的，又做了高并发的设计(Java出生时(1995)还没有多核cpu,所以他的并发支持后来添加上去的,Go(2009)出生时已经有了多核cpu的电脑，它在设计语言时就考虑了充分利用多核cpu(英特尔2005首次推出多核)的性能)，所以性能高，高并发的支持(高并发支持其中指的一个就是充分利用多核cpu的性能资源，比如go程序默认使用所有cpu(除非自己设置使用多少))也好。
    
    	*.天然的适用一些特定系统的开发，比如区块链类系统(如以太坊底层系统、以太坊上层应用程序)，云计算和容器（Docker，K8s底层都是go开发的）开发的(大公司自研运维管理项目也大多是用go做底层的开发)，网络编程(类似于java的Netty)。

#### 3.Go和Java的语言类型区别 ####

计算机编程语言按照运行的方式可以分为编译型编程语言和解释型编译语言。

我来举一个例子，你要教别人一门沟通交流的语言，比如英语。

编译型的教的方式就是录(这里的录相当于计算机中把程序编译成二进制可执行文件)一个视频课程，语音课程，把每一句英语发音录下来，这样学生学的时候只要播放你的录音，然后跟着读就行，你只需要录制一次，学生就可以无数次听。

解释性的教的方式就是你亲自到学生家里给他补习，你当面教他，你读(读相当于每次执行都重新用解释器解释一遍)一句他学一句，

这样的话，你想要教他一句你必须就得先读一句，每次教都得重新一遍一遍的读。

这两种教学方式还有一个差别，你录(编译)视频语音教他，你录的英语他就只能学英语，空间环境一变，他现在要去日本，要学日语，你的视频语音教程因为已经录好了，是英语类型(英语类型类比操作系统类型)的，所以，你就得再录一套日语的语音教程。

而现场教他，你也会日语的话，你只需要读(读相当于解释器解释)日语给他听，让他学就行了，是不用考虑语言环境(操作系统类型环境)不同的问题的。

现在我们再来看编程语言，我们的程序执行有两种方式，一种是编译成操作系统可执行的二进制可执行程序，这样相当于编译一次，之后每次执行都不用再编译了，但是因为不同操作系统对于二进制文件的执行规范不同，不同的操作系统你要编译成不同的可执行文件。

解释型语言就是多了一个解释器，解释器我们可以类比为一个老师，你执行一行代码我们类比为学一句话的读音，解释器解释一句，就是老师先读一句，你跟着才能读一句，也就是解释器每解释一行代码为可运行的代码，操作系统执行一行代码，这样的话每次执行都需要解释器重新解释一遍，执行几次就得解释几次。

Go是编译型的语言，运行在不同的平台需要打包成不同操作系统类型下的可执行文件。

Java是半编译，半解释型语言。编译是指他的代码都会编译成class类型的文件，class类型的文件只需要编译一次，可以在不同的操作系统的Java虚拟机上执行 ，半解释是指在Java虚拟机中，他还是需要一句一句的将class的二进制代码解释成对应操作系统可执行的代码。

#### 4.Go语言目前的主要应用场景 ####

*.和Java一样，Go语言最多的应用场景就是服务器后端系统的开发，包括Web后端，微服务后端接口。
    
    	*.Go非常适用需要高性能高并发的网络编程，这里的网络编程是指不需要界面，底层只是用Socket相互传输数据的系统，类似于Java中Netty的用途。
    
    	*.一些云计算容器，比如Docker，K8s，底层就是Go语言开发的，也可以用做底层自研运维项目的开发。
    
    	*.一些游戏系统的开发，可以用Go语言。
    	
    	*.区块链的一些底层软件和一些应用软件。(区块链程序的第一开发语言)

#### 5.现在市场上都有哪些公司在使用Go语言？ ####

我们不讲虚的，直接BOSS直聘看哪些公司招，招的是干什么系统开发的。

这是腾讯的一个岗位。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WaQoAeZy-1635003354070)(.\\tengxun\_baoxian.jpg)\]

看看岗位描述，是做互联网保险 产品的业务系统开发，业务系统是啥意思，和JAVA后端业务系统一样啊，说明腾讯的一部分项目已经用Go来开发业务系统了， 至少他这个保险团队是这样的。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L8OGo3Wd-1635003354077)(.\\tengxun\_baoxian\_detail.jpg)\]

再看小米也是：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RYae2NNS-1635003354080)(.\\xiaomi.jpg)\]

也是后端，这是要和JAVA抢饭碗。。。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xdeGt6YB-1635003354083)(.\\xiaomi\_detail.jpg)\]

再看一个常见的，Go非常适合开发运维管理系统，这个估计是开发维护阿里内部的自动化运维项目的，也就是说他们的运维支持可能是他们自己用Go语言写的项目。(实在不理解你就想下他们自己自研开发了一个类似于Jenkins和Docker之类的环境和代码流程发布的项目)

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8VgXoH0b-1635003354087)(.\\aliyunwei.jpg)\]

再来看一个字节跳动的，也是开发内部流程自动部署自动运维程序的

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RPmm39A4-1635003354089)(.\\zijietiaodong.jpg)\]

再看华为的，好像Java架构师的要求啊，微服务，缓存，消息中间件，数据库。。。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nw2b7fo7-1635003354091)(.\\huawei.jpg)\]

这里不多看，自己看看去吧，大多数你能知道的大公司都有用go语言尝试的新部门，新项目，市场占有率虽然比Java少，但是岗位实际上蛮多的。自己可以去BOSS上详细查查。

### 三.Go和Java微观对比 ###

#### 1.GoPath和Java的ClassPath ####

我们先来看看关于Java的classpath：

在我们的开发环境中，一个web程序(war包)有一个classpath,这个classpath在IDEA的开发工具中目录体现为src目录和resource目录，实际上在真正的war包中他定位的是指WEB-INF下的classes文件夹下的资源(比如class文件)。

我们编译后的文件都放在classpath(类路径)下。我们多个项目程序会有多个classpath目录。

在Go语言中，GoPath在同一系统上的同一用户，一般规定只有一个，无论这个用户创建多少个go项目，都只有一个GoPath,并且这些项目都放在GoPath下的src目录下。

GoPath下有三个目录：

1.bin （用于存放项目编译后的可执行文件）

2.pkg (用于存放类库文件，比如.a结尾的包模块)

3.src （用于存放项目代码源文件）

注意：当我们在windows上开发Go程序时，需要新建一个文件夹(文件夹名任意)作为GOPATH的文件目录，在其中新建三个文件夹分别是：bin,pkg,src。如果是在集成开发工具上开发的话，需要在设置中把GOPATH路径设置为你自定义的那个文件夹，之后产生的文件和相关内容都会在其中。

如果是在linux上想跑测试开发执行go程序，需要在/etc/profile添加名为GOPATH的环境变量，目录设置好自己新建的。

例如：全局用户设置GOPATH环境变量

vi /etc/profile#添加如下 目录可以灵活修改export GOPATH=/pub/go/gopath//立即刷新环境变量生效source /etc/profile

单用户设置GOPATH环境变量

vi   ~/.bash_profile#添加如下 目录可以自己灵活修改export GOPATH=/home/user/local/soft/go/gopath//立即刷新环境变量生效source vi   ~/.bash_profile

注意：这是在linux上开发go程序才需要的，如果只是生产运行程序的话是不需要任何东西的，直接运行二进制可执行程序包即可，他所有的依赖全部打进包中了。

如果是在windows下的cmd，dos窗口运行相关的go命令和程序，则需要在windows的【此电脑】–>【右键】–>【属性】–>【高级系统设置】–>【环境变量】-【新建一个系统变量】–>【变量名为GOPATH，路径为你自己指定的自定义文件夹】（如果是在IDEA中开发，不需要在此配置环境变量，只需要在IDEA中配置好GOPATH的目录设置即可）

#### 2.Go的开发环境搭建 ####

（配置环境变量GOPATH参考上一节内容）

我们要开发Go的程序，需要如下两样东西：

1.Go SDK

GO中文社区SDK下载地址：https://studygolang.com/dl

go1.14(最新的)

我们用1.14版就可以，因为1.13后才完全支持Module功能。

有两种安装模式，一种是压缩包解压的方式，一种是图形化安装。

推荐使用windows图形安装傻瓜式安装，windows图形安装下载这个

https://studygolang.com/dl/golang/go1.14.6.windows-amd64.msi

linux安装如下：

后续补上。。。

1.  Go的集成软件开发环境
    
    参考三(4)中的go集成开发环境选择。

#### 3.Go与Java的文件结构对比 ####

##### 1).go文件结构模板 #####

//主程序必须是写成main包名package main//导入别的类库import "fmt"    //全局常量定义const  num = 10  //全局变量定义var name string = "li_ming"//类型定义type P struct {}  //初始化函数func init() {}//main函数:程序入口func main() {	fmt.Printf("Hello World!!!");}

##### 2).Java文件结构 #####

//包名package my_package;       //导入包中的类import java.io.*；public Class MainTest{ 	//main方法:程序入口    public void static main(String[] args) {		}}//people类Class People {	//成员变量	public String name;	public int age;            	//成员方法	public void doSomething() {	            	}    }

#### 4.Go与Java的集成开发环境 ####

##### 1).Go的集成开发环境 #####

最常用的有三种：Visual Studio Code(VS Code) 微软开发的一款Go语言开发工具。LiteIDE 是国人开发的Go语言开发工具。GoLand 这个非常好用，和Java中的IDEA是一家公司。(推荐使用)

##### 2).Java的集成开发环境 #####

MyEclipse,Eclipse(已过时)。IntelliJ IDEA(大多数用这个)。

#### 5.Go和Java常用包的对比 ####

Go中文API文档地址：https://studygolang.com/pkgdoc

Go                                              Java         IO流操作：      bufio/os                                     java.lang.io字符串操作：      strings                                    java.lang.String容器           container(heap/list/ring)           	      java.lang.Collection锁               sync                                       juc时间              time                                      java.time/java.lang.Date算数操作          math                                       java.math底层Unsafe       unsafe                                     unsafe类

#### 6.Go的常用基础数据类型和Java的基础数据类型对比 ####

##### 1).go中的常用基础数据类型有： #####

1.布尔型：关键字【bool】： true   false2.有符号整形：头一位是代表正负            int   默认整形   4或8字节         		  32位或64位                 int8             1字节                     8位            int16            2字节                     16位            int32            4字节                     32位            in64             8字节                     64位       		【int是32还是64位取决于操作系统的位数，现在电脑一般都是64位的了，所以一般都是64位】3.无符号整形            uint             4或8字节          	 32位或64位            uint8             1字节                     8位            uint16            2字节                     16位            uint32            4字节                     32位            uint64            8字节                     64位4.浮点型            注：go语言没有float类型，只有float32和float64。            float32           32位浮点数              float64           64位浮点数5.字符串            string6. byte     等同uint8，只是类似于一个别名的东西   rune     等同int32	 只是一个别名，强调表示编码概念对应的数字

##### 2).go中派生数据类型有： #####

注:这里简单列举一下指针  	Pointer数组  	Array[]结构体 	struct进程管道： channel 函数 		 func切片  	slice接口 		interface哈希 		 map

##### 3).Java中的基础数据类型 #####

byteshortintlongfloatdoublebooleanchar

#### 7.Go和Java的变量对比 ####

##### 1).go的变量 #####

package mainimport(   //包含print函数   "fmt")func main() {   //var  变量名  变量类型 = 变量值   var name string = "li_ming"   //方法内部可以直接使用 【 变量名 := 变量值 】 赋值，方法外不可以   name2:="xiao_hong"   fmt.Println("name = ",name)   fmt.Println("name2 = ",name2)}

##### 2).Java的变量 #####

public class MyTest {
       
            public static void main(String[] args) {
       
                //变量类型  变量名 = 变量值        String name = "li_ming";        int i = 10;        System.out.println("name ="+name);        System.out.println("i ="+i);    }}

#### 8.Go和Java的常量对比 ####

##### 1).go的常量 #####

go中的常量和java中的常量含义有一个本质的区别：go中的常量是指在编译期间就能确定的量(数据)，而java中的常量是指被赋值一次后就不能修改的量(数据)。所以两者不一样，因为Java中的常量也是JVM跑起来后赋值的，只不过不允许更改；go的常量在编译后就确实是什么数值了。

package mainimport(   //包含print函数   "fmt")func main() {   //const  常量名  常量类型 = 常量值   显示推断类型   const name string = "const_li_ming"   //隐式推断类型   const name2 ="const_xiao_hong"   fmt.Println("name = ",name)   fmt.Println("name2 = ",name2)}

##### 2).Java的常量 #####

public class MyTest {
       
            //【访问修饰符】 【静态修饰符】final修饰符   常量类型   常量名 =  常量值；    public static final String TAG = "A";    //一般设置为static静态    public static void main(String[] args) {        System.out.println("tag= "+TAG);    }}

#### 9.Go与Java的赋值对比 ####

##### 1).go的赋值 #####

Go方法内的赋值符号可以用  := ,也可以用 =,方法外只能用 = 。例如:

package mainimport(   //包含print函数   "fmt")//方法外只能用 = 赋值var my_name  string = "my_name"var my_name2 = "my_name2"//my_name3:="my_name3"    不在方法内，错误func main() {   fmt.Println("name = ",my_name)   fmt.Println("name2 = ",my_name2)}

Go支持多变量同时赋值：

package mainimport(   //包含print函数   "fmt")func main() {   //多变量同时赋值   var name,name2 = "li_ming","xiao_hong"   fmt.Println("name = ",name)   fmt.Println("name2 = ",name2)}

Go的丢弃赋值

package mainimport(   //包含print函数   "fmt")func main() {   //丢弃赋值    把 1和2丢弃 只取3   //在必须一次取两个以上的值的场景下，又不想要其中一个值的时候使用，比如从map中取key,value   var _,_,num = 1,2,3   fmt.Println("num = ",num)}

##### 2).java的赋值 #####

public class MyTest {
       
            public static void main(String[] args) {
       
                //直接用 = 赋值        String name = "li_ming";        int i = 10;        System.out.println("name ="+name);        System.out.println("i ="+i);    }}

#### 10.Go与Java的注释 ####

Go中的注释写法和Java中的基本一样。例如：//单行注释,两者相同/*    Go的多行注释*//**	Java多行注释*/

#### 11.Go和Java的访问权限设置区别 ####

首先我们来回忆一下，Java的权限访问修饰符有哪些？

public 全局可见

protected 继承相关的类可见

default 同包可见

private 私有的，本类可见

关于Java中的访问权限修饰符，是用于修饰变量，方法，类的，被修饰的对象被不同的访问权限修饰符修饰后，其它程序代码要想访问它，必须在规定的访问范围内才可以，比如同包，同类，父子类，全局均可访问。

那么，Go中的访问权限设置又有什么区别呢？

要理解这个问题，首先我们要来看一下一个Go程序的程序文件组织结构是什么样子的？

一个可运行的编译后的Go程序，必须有一个入口，程序从入口开始执行，这个入口必须是main包，并且从main包的main函数开始执行。

但是，为了开发的效率和管理开发任务的协调简单化，对于代码质量的可复用，可扩展等特性的要求，我们一般采用面向对象的，文件分模块式的开发。

比如，我是一个游戏程序，我的main函数启动后，首先要启动UI界面，那么关于UI界面相关的代码我们一般会专门分出一个模块去开发，然后这个模块有很多个程序文件，这里关于UI模块比如有3个文件，a.go,b.go,c.go，那么我们在实际当中会建一个以ui为名的包文件夹，然后把a.go,b.go,c.go全部放到ui这个包文件夹下，然后因为这个包没有main包，没有main函数，所以它打出来的一个程序文件就是以.a结尾的工具包，类似于Java中的jar包，工具包文件名为 ui.a。

参考如下：

\----com.mashibing.mygame.ui

\------------------------------------a.go

\------------------------------------b.go

\------------------------------------c.go

a.go文件如下示例：

//这里的ui，也就是package后面的名称尽量和包文件夹的名称一致，不一致也可以package ui//相关方法和业务func main() {   }//启动游戏UIfunc StartGameUI() {}

这里需要注意一个点，在程序中的 package后面的 ui包名可以和文件夹com.mashibing.mygame.ui中最后一层的ui文件夹名称不一致，

我们一般按规范写是要求写一致的，不一致时的区别如下：

我们把ui.a打包完毕后，我们就可以在别的程序中用import导入这个包模块 ，然后使用其中的内容了。

上面两个ui不同之处在于，在我们import 的代码后面，需要写的模块名称是在 $\{gopath\}/src/下的文件夹名，也就是com.mashibing.mygame.ui中的ui。

例如：

//游戏主程序package main//这里的ui是com.mashibing.mygame.ui的最后一层文件夹名import "ui"//相关方法和业务func main() {	//这里的ui不是文件夹名，而是之前a.go程序中package后面写的包名	ui.StartGameUI()}

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y9RrRcsY-1635003354093)(.\\001fmt.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yErPGDZm-1635003354096)(.\\002fmt.png)\]

接下来进入主题，我们的go语言关于访问修饰符的是指的限制什么权限，以及如何实现？

我们之前可以看出来，实战中的go程序是有一个main程序import很多其它包模块，每个模块实现对应的功能，最后统一在main程序中组合来完成整个软件程序，那么有一些其它模块的函数和变量，我只想在本程序文件中调用，不想被其它程序import能调用到，如何实现？

import后是否能调用对应包中的对象(变量，结构体，函数之类的)就是go关于访问权限的定义，import后，可以访问，说明是开启了访问权限，不可以访问，是说明关闭了其它程序访问的权限。

在go中，为了遵循实现简洁，快速的原则，用默认的规范来规定访问权限设置。

默认规范是：某种类型（包括变量，结构体，函数，类型等）的名称定义首字母大写就是在其它包可以访问，首字母非大写，就是只能在自己的程序中访问。

这样我们就能理解为什么导入fmt包后，他的PrintF函数的首字母P是大写的。

参照如下代码：

package uiimport "fmt"func main() {   //这里的P是大写   //所有调用别的包下的函数，都是首字母大写   fmt.Printf("aa")}//这里的Person的首字母P也是表示外部程序导入该包后可以使用此Person类type Person struct{}//这里的D同上var Data string = "li_ming"

#### 12.Go与Java程序文件的后缀名对比 ####

Java的编译文件是.class结尾,多个.class打成的一个可执行文件是.jar结尾,.jar不能直接在windows和linux上执行,得用java命令在JVM中执行。Go语言的程序文件后缀为.go,有main包main函数的,.go文件打包成二进制对应操作系统的可执行程序,如windows上的.exe结尾的可执行程序。Java的类库会以.jar结尾，Go语言非main包没有main函数的程序编译打包会打成一个类库，以.a结尾,也就是说Go语言的类库以.a结尾。Go的类库如下:            包名.a                 my_util.a注：my_util是最顶层文件夹名，里面包含着一个个程序文件。

#### 13.Go与Java选择结构的对比 ####

##### 1).if #####

Go中的if和Java中的if使用相同，只不过是把小括号给去掉了。

示例1：

package mainimport (   "fmt")func main() {
       
           /*      单分支结构语法格式如下:         if 条件判断 {            //代码块         }   */   var num int   fmt.Printf("请输入数字")   fmt.Scan(&num)   if num > 10 {
       
              fmt.Println("您输入的数字大于10")   }}

示例2：

package mainimport (   "fmt")func main() {
       
           /*      if else分支结构语法格式如下:         if 条件判断 {            //代码块         } else {            //代码快2         }   */   var num int   fmt.Printf("请输入数字")   fmt.Scan(&num)   if num > 10 {
       
              fmt.Println("您输入的数字大于10")   } else {
       
              fmt.Println("您输入的数字不大于10")   }}

示例3：

package mainimport (   "fmt")func main() {
       
           /*      if else分支结构语法格式如下:         if 条件判断 {            //代码块         } else if 条件判断{            //代码块2         } else {            //代码块3         }   */   var num int   fmt.Printf("请输入数字")   fmt.Scan(&num)   if num > 10 {
       
              fmt.Println("您输入的数字大于10")   } else if num == 10{
       
              fmt.Println("您输入的数字等于10")   } else {
       
              fmt.Println("您输入的数字小于10")   }}

##### 2).switch #####

示例1：

package mainimport (   "fmt")func main() {
       
           var a = "li_ming"   switch a {
       
           case "li_ming":      fmt.Println("Hello!LiMing")   case "xiao_hong":      fmt.Println("Hello!XiaoHong")   default:      fmt.Println("No!")   }}

示例2：一分支多值

package mainimport (   "fmt")func main() {
       
        	   var name = "li_ming"   var name2 = "xiao_hong"   switch name {
       
           //li_ming或xiao_hong 均进入此   case "li_ming", "xiao_hong":      fmt.Println("li_ming and xiao_hong")   }   switch name2 {   case "li_ming", "xiao_hong":      fmt.Println("li_ming and xiao_hong")   }}g

示例3：switch表达式

package mainimport (   "fmt")func main() {
       
           var num int = 11   switch{
       
              case num > 10 && num < 20:         fmt.Println(num)   }}

示例4：fallthrough下面的case全部执行

package mainimport