Java转Go入门学习

大家好，最近感觉java有点难了，决定重新找门语言再重新学习一下，提升一下自己。于是，听公司一个十年经验的老大哥说，目前rust和golang语言是比较不错的，刚好周末有空去图书馆借了本《Go语言入门经典》这本书，看完总结了一下，废话不多书说，这篇博客呢，适用于有编程经验的童鞋，之前接触过的，从Java的角度来快速学习的go语言。

Golang语言的吉祥物 Gopher:

首先，先简单介绍下Go语言，又称Golang，是Google在2007年开发的一种开源编程语言，出自罗伯特·格里斯默，罗布·派克 和肯·汤普逊之手，都是大佬，2009年11月10日，Google Open Source Blog向全世界发布这款语言；指出主要目标为"兼具python等动态语句的开发速度和C或C++等编译型语言的性能和安全性"，也是一种面向对象的高级语言。

编译型语言: 是一种在程序执行之前需要通过编译器将源代码转换为机器代码（或字节码）的编程语言。编译过程通常会将高级语言的源代码转换成目标平台可以直接执行的机器语言指令，或者转换成一种中间形式（如字节码），然后由虚拟机解释或进一步编译执行。

以下是Go语言的一些主要特点：

简洁易学

语法设计简单明了，易于学习和使用，尤其适合初学者和从其他编程语言转移过来的开发者。

高效编译

具有快速的编译速度，编译器可以迅速将源代码转换为可执行的机器代码，即使是大型项目也能在几秒钟内完成编译。

静态类型

静态类型语言，编译时进行类型检查，能在开发过程中发现许多潜在的错误，增强代码安全性与可靠性。

内存安全

提供了自动垃圾回收机制，减少了内存管理的复杂性，防止了内存泄漏和悬空指针等问题。

内置并发

通过goroutine和channel实现了内置的并发支持。goroutine是比线程更轻量级的协程，可以轻松创建大量并发任务，而channel用于安全地在goroutine之间传递数据。

丰富的标准库

拥有丰富且强大的标准库，涵盖了网络编程、文件I/O、字符串处理、加密等多个方面，极大地方便了开发者的工作。

跨平台编译

支持跨平台编译，可以在一个平台上编译出适用于不同操作系统（如Windows、Linux、macOS等）的可执行文件。

独立的可执行文件

编译后的Go程序是独立的可执行文件，不需要额外的运行时环境或依赖库，方便部署和分发。

1.Hello World

安装的话这里就不展示了，大概步骤为，拉取安装包 > 配置安装环境 > 使用go version命令验证安装是否成功，紧接着开始编写您的第一个Go程序——Hello World!

编译器我使用的Vs code，再安装个Go插件就行

ps:在windows环境操作

package main//声明了一个包。与Java一致 main包的话是一个特殊的包，代表这个包包含一个可执行程序的入口点。可执行的Go程序必须有且只有一个main包。在包内必须包含一个main函数作为程序入口，且Java得声明类名

import "fmt"//fmt包：fmt是格式化输入和输出的标准库包。它提供了格式化字符串的函数，比如打印到控制台的Println函数。

func main() {
    fmt.Println("Hello, World!")//打印
}

编写完打开cmd小黑窗，运行程序 go run main.go即可

2.基础数据类型

整数类型（Integer Types）：

int：平台相关的有符号整数类型，通常为32位或64位。

int8、int16、int32、int64：有符号整数类型，分别为8位、16位、32位和64位。

uint：平台相关的无符号整数类型，通常为32位或64位。

uint8、uint16、uint32、uint64：无符号整数类型，分别为8位、16位、32位和64位。

浮点数类型（Floating-Point Types）：

float32：32位浮点数类型。

float64：64位浮点数类型。

复数类型（Complex Types）：

complex64：由两个float32类型的浮点数组成的复数类型。

complex128：由两个float64类型的浮点数组成的复数类型。

布尔类型（Boolean Type）：

bool：表示逻辑值的布尔类型，只能是true或false。

字符串类型（String Type）：

string：表示文本字符串的数据类型，使用双引号"或反引号```括起来。

package main

import (
	"fmt"
	"reflect"//use reflect check data type
    "strconv"
)

func main() {
	var num int = 42
	var str string = "Hello, World!"
	var arr = []int{1, 2, 3}
    //print data type
	fmt.Println(reflect.TypeOf(num));
    fmt.Println(reflect.TypeOf(str));
    fmt.Println(reflect.TypeOf(arr));
    str := "42"
	// 将字符串转换为整数类型
	str := strconv.Atoi(str)
	var b bool = true
    //布尔字符输出
	fmt.Println(reflect.TypeOf(strconv.FormatBool(flag)));
}

ps：本章了解下

3.理解变量

使用过编程语言，就不会对变量陌生

变量声明与初始化

声明并初始化

var age int = 30
var city = "Beijing" // 类型推断

简短声明（仅限函数内）

count := 10
message := "Hello, Go"

作用域与生命周期

局部变量

声明在函数内，作用域和生命周期仅限于函数内。

func main() {
    var localVar = "I'm local"
    fmt.Println(localVar)
}

全局变量

声明在函数外部，作用域为整个包，生命周期贯穿程序运行期。

var globalVar = "I'm global"

特殊变量

空白标识符 _

用于忽略值。

_, b := someFunction()

多变量声明与赋值

一次声明和初始化多个变量。

var x, y, z int = 1, 2, 3
a, b, c := 4, 5, "six"

常量

声明常量

const Pi = 3.14
const Greeting = "Hello, World"

枚举常量

使用 iota 生成一系列相关值。

const (
    Red = iota
    Green
    Blue
)

命名规范

变量名应具有描述性，推荐使用驼峰命名法（这都熟的不能再熟了吧）。

var userName string
var userAge int

总结：该篇理解了Go语言中的数据类型，程序是由数据类型和逻辑代码组成

//ALL Statement variable
var s string = "Hello World"
var s = "Hello World"
var t string
t = “Hello World”
u := "Hello World"
var s, t string = "foo","bar"
var {
	s1 string  = "foo"
	i int = 4
}

4.创建函数及调用

函数，在Java为方法，同样的在Go中也是非常重要的一环。

简单，说下和Java的区别

Go使用func声明,可以独立生存，不依赖于类，且支持多返回值，入参于返回值都可以有命名

Java 必须定义在类中，只支持单一返回值，多返回值使用对象完成

还有多种，这里就不详细说了，接下来写些简单声明的示例

//字符拼接
func out(a string) string {
	return "Susan "+ a
}

//base Method
func sum(a int,b int) int {
	return a + b
} 

//Many Param
func returnMany(a int,b int) (int,int) {
	return a,b
}

//返回值命名
func divide(a int, b int) (quotient int, remainder int) {
    quotient = a / b
    remainder = a % b
    return
}

//可变参数
func sum(numbers ...int) int {
    total := 0
    for _, number := range numbers {
        total += number
    }
    return total
}

//调用
result := add(3, 4)
quotient, remainder := divide(10, 3)

Go还支持函数作为值和类型，为入参

// 函数作为值
func add(a, b int) int {
    return a + b
}

func subtract(a, b int) int {
    return a - b
}

// 函数作为参数
func applyFunction(a, b int, operation func(int, int) int) int {
    return operation(a, b)
}

func test1()  {
	operation := add
	result := operation(3, 4)
	fmt.Println("Addition result:", result)
	
	operation = subtract
	result = operation(7, 2)
	fmt.Println("Subtraction result:", result)
	
}

func main()  {
	result := applyFunction(3, 4, add)
	fmt.Println("Addition result:", result)
	result = applyFunction(7, 2, subtract)
	fmt.Println("Subtraction result:", result)
}

这里会有一个operation函数，这里解释一下。具体来说，operation 是一个函数类型的参数，它接受两个整数参数并返回一个整数结果。在 applyFunction 函数内部，我们调用 operation(a, b)，就是在调用传递进来的函数，并将参数 a 和 b 传递给它。这样，我们可以在 applyFunction 函数中使用不同的函数来执行不同的操作，实现了函数的动态调用。

总结，该章节是对函数的调用，以及声明函数的操作，这里不适应的应该是和Java的不太一样了。

5.控制流程

本章有如If，else和else if语句，switch语句，for循环语句，defer(Go)语句

这个也比较容易理解，比零基础学轻松了许多哈，直接贴出示例代码

package main

import "fmt"

func main() {
    //go特性函数
    defer fmt.Println("最爱陶吉吉的十七岁")
    x := 10

    if x > 5 {
        fmt.Println("x is greater than 5")
    } else {
        fmt.Println("x is less than or equal to 5")
    }
    
    day := "Sunday"
    switch day {
    case "Monday":
        fmt.Println("It's Monday")
    case "Tuesday":
        fmt.Println("It's Tuesday")
    default:
        fmt.Println("It's another day")
    }
    
     // for循环
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    
    numbers := []int{62,3,54,7,9}
	for i,n := range numbers {
		fmt.Println("遍历的key",i)
		fmt.Println("遍历的value",n)
	}
}

总结：本章大概有这些，值得注意的是第一行有个defer语句，defer 是 Go 语言中的一个关键字，用于确保一个函数调用在其所在函数结束时被执行。即使函数因 return 语句提前返回，或在执行过程中发生错误（panic），defer 语句仍然会被执行。它通常用于资源清理，例如关闭文件、解锁互斥锁等。