Java 转 Go 之初体验-CSDN博客

开发者（KaiFaX）
面向全栈工程师的开发者
专注于前端、Java/Python/Go/PHP的技术社区

来源：blog.csdn.net/tiantang_zy/article/details/105048817

面试了一个单位说可能需要java转go语言所以在此开始学习一下如果面试通过了就继续学没面试过那么就这一篇了加油！！！

一、万能之Hello World 开启go的大门

直接上代码

package main //表明包

import "fmt" //导入包 fmt 控制输入输出 感觉和java的System.out和Scanner有点像

func main() {
    fmt.Println("Hello Go world。"); //进入这个世界了
}

输出结果:

是不是感觉还可以。

二、Go语言环境安装

安装包下载地址为：https://golang.org/dl/。

如果打不开可以使用这个地址：https://golang.google.cn/dl/。

我安装的是windows版的双击安装选择目录全程轻松随意比想象中简单

配置系统变量，然后就可以开始玩了

三、基础语法

行分割符：不需要像java一眼每句之后都加一个;表明结束每一行都是单独的一句如果非要把几行语句写在一起就需要加分号了
注释 : //单行注释
/*
aaa
bbb
*/
标识符标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(AZ和az)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
字符串连接直接用+号即可连接这点倒是和java挺像的但是java里直接用加号连接的性能不是很好不知道go语言中是否有相类似的编译流程
关键字
预定义标识符

四、数据类型

数据类型详细的可以看这个：https://www.runoob.com/go/go-data-types.html
首先一点，给我印象比较深的就是对数字类型添加了很多的包装，在不同的应用范围内使用不同的数据类型例如

int8 有符号 8 位整型 (-128 到 127)
int16 有符号 16 位整型 (-32768 到 32767)
int32 有符号 32 位整型 (-2147483648 到 2147483647)
int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
这个给人感觉就是对使用着感觉有了更高的要求像java就是int Integer BigInteger这几种包装好的用就行了
当然这样要求的更细致感觉编译的时候就越容易控制如果方方面面都这么细致的话运行速度上就可以提高不少的

五、声明变量

```
var identifier type 例：var a int;
```

var identifier1,identifier2 type 例：var a,b string;

```
指定变量类型，如果没有初始化，则变量默认为零值
数值类型（包括complex64/128）为 0
```
布尔类型为 false
字符串为 “”（空字符串）
以下几种类型为 nil：
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

根据值自行判定变量类型 例：var d = true （这点就有点像js了）

省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：v\_name := value 例：f := “Runoob”

```
多变量声明
```

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

// 和 python 很像,不需要显示声明类型，自动推断
var vname1, vname2, vname3 = v1, v2, v3 

// 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
vname1, vname2, vname3 := v1, v2, v3 


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

六、常量

const 定义常量关键字目前感觉和final static 类似
定义了之后就不能改了如果代码里面改了的话会报 cannot assign to LENGTH 错误

下来就发现一个神奇懂东西 iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

枚举自增计数器感觉是这么个意思

运算符

&这个就是只有两个1的时候才是1其余都是0
|这个是只有两个0的时候才是0其余都是1和与刚好相反
^这个简单粗暴两个相同的数字是0不同的时候是1

这个<<=后面的几个都还有点惊艳到我了厉害厉害

这两个优点没太看懂敲个代码试一下

package main

import "fmt"

func main(){
 var a string = "abc"
 var ptr *string = &a
 fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
 fmt.Printf("第 2 行 - ptr  变量类型为 = %T\n", ptr );
 fmt.Println(*ptr)
 fmt.Println(ptr)
}

加*输出的是内容不加输出的就是地址这个指针的概念 java里是没有的

这一part 感觉除了指针的概念其余的感觉都差不多

七、条件语句

这个select语句真的是看的我欲生欲死
以下描述了 select 语句的语法：

每个 case 都必须是一个通信
所有 channel 表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。
否则：
如果有 default 子句，则执行该语句。
如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。

来来来两段代码说明一下

package main

import (
    "fmt"
)

func fibonacci(c, quit chan int) {
    x, y := 1, 1
 
    for {
        select {
        case c <- x:
      fmt.Printf("x : %d, y : %d\n", x, y)
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)

    go func() {
        for i := 0; i < 6; i++ {
      fmt.Printf("开始搞事 i = %d\n", i)
            fmt.Println(<-c)
        }
        quit <- 0
    }()

    fibonacci(c, quit)
}

输出结果为：

第二段代码：

package main

import (
    "fmt"
    "time"
)

func Chann(ch chan int, stopCh chan bool) {
    for j := 0; j < 10; j++ {
        ch <- j
        time.Sleep(time.Second)
    }
    stopCh <- true
}

func main() {

    ch := make(chan int)
    c := 0
    stopCh := make(chan bool)

    go Chann(ch, stopCh)

    for {
        select {
        case c = <-ch:
            fmt.Println("Recvice", c)
            fmt.Println("channel")
        case s := <-ch:
            fmt.Println("Receivessss", s)
        case _ = <-stopCh:
            goto end
        }
    }
end:
}

输出结果为：

这两个例子分别说明了下面两点
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。