【Java转Go】快速上手学习笔记（二）之基础篇一

创建项目

上篇我们安装好了Go环境，和用IDEA安装Go插件来开发Go项目：【Java转Go】快速上手学习笔记（一）之环境安装篇 。

这篇我们开始正式学习Go语言。我是看B站的视频边学边看着视频敲代码的，所以代码笔记也是按照视频讲的顺序来写的。

（然后还有个点需要说明一下，就是我这个笔记应该是只适合有其他编程语言基础的人看，如果没有其他语言基础，还是要找视频或资料系统的学习）

首先是创建一个项目：

项目创建好后，new一个Go File。

数据类型

这里先说一下go的数据类型，主要分为四大类：布尔类、数字类、字符串类、派生类

布尔类就是true、false；数字类就是浮点数和整型；字符串类就字符串咯；派生类就比较多了，包括了指针类型（Pointer）、 数组类型、结构化类型(struct)、Channel 类型、函数类型、切片类型、接口类型（interface）、 Map 类型

go中，所有数据类型都有一个默认值（零值），整型、浮点默认值是0，字符串类型默认是空字符串，布尔类型默认是false。

变量常量

package main

import "fmt"

// 这里是全局变量
var num int = 100

/*
这个是main函数，这是go语言启动的入口
*/
func main() {
	fmt.Print("hello！world！") // 不换行打印
	fmt.Println("我是符华呀~")     // 换行打印
	fmt.Println("我是" + "符华呀") // 字符串连接，用+实现，打印的是：我是符华呀~

	// var 变量名 数据类型
	var name string = "符华" // 定义一个字符串变量
	var age int = 20       // 定义一个int变量
	name = "赤鸢"            // 改变name变量的值
	fmt.Println(name, age) // 打印name和age值，多个值直接用逗号隔开
	
	// 不过像版本较高的sdk，其实定义变量的时候，不用指定数据类型也可以，会自动识别，例如：
	//var name,age,a,b = "符华",20,1.56,true
}

注意，Go语言是不用写分号的（编译的时候会默认帮我们加分号），一行就是在最后默认加一个分号，一句代码就是一行，不可以把多句代码写在一行。

不过要是非得写一行，一句代码用分号分隔也是可以的，但是不建议这么写。而且我用的idea，我这么写后，会自动帮我格式化分成两行并且把分号去掉了。

当我们要拼接一个长字符串的时候，需要换行，这时，我们需要把换行的加号保留在上一行

除了用var声明变量外，还可以用 := 声明短变量。

类型转换

go中，基本数据类型的类型转换必须显示转换（强制转换），不能自动转换。 转换的表达式：T(v)，T表示数据类型，v表示要转换的变量。转换时，被转换的是变量存储的值，变量本身的数据类型并没有发生变化。

其他类型转string,使用 fmt.Sprintf

计数器

键盘交互

流程控制

流程控制语句：if、switch、for

if这个没啥好说的，就是 if、else、else if，这个和Java一样。

代码

上面说到的代码全在这里了，大家可以复制下来，自己从上到下一个一个去执行一遍（放开注释），加深下印象。

package main

import (
	"fmt"
)

// 这里是全局变量
var num int = 100

/*
这个是main函数，这是go语言启动的入口
*/
func main() {
	fmt.Print("hello！world！") // 不换行打印
	fmt.Println("我是符华呀~")     // 换行打印
	fmt.Println("我是" + "符华呀") // 字符串连接，用+实现，打印的是：我是符华呀~

	// var 变量名 数据类型
	//var name string = "符华" // 定义一个字符串变量
	//var age int = 20       // 定义一个int变量
	//name = "赤鸢"            // 改变name变量的值
	//fmt.Println(name, age) // 打印name和age值，多个值直接用逗号隔开

	// 不过像版本较高的sdk，其实定义变量的时候，不用指定数据类型也可以，会自动识别，例如：
	//var name,age,a,b = "符华",20,1.56,true

	// 字符串除了用双引号，还可以用反单引号，也就是 `这里是内容`
	// 当我们有一个比较复杂的字符串时，用双引号遇到特殊字符需要转义，而且拼接比较麻烦，这时我们可以用反单引号
	var str = "abc\nabc"
	str = `abc\nabc`
	str = `
		package main
		import "fmt"
		func main() {
			fmt.Print("hello！world！") // 不换行打印
			fmt.Println("我是符华呀~")     // 换行打印
			fmt.Println("我是" + "符华呀") // 字符串连接，用+实现，打印的是：我是符华呀~
			var name string = "符华" // 定义一个字符串变量
			var age int = 20       // 定义一个int变量
			fmt.Println(name, age) // 打印name和age值，多个值直接用逗号隔开
		}
	`
	fmt.Println(str)

	/*
		定义多个变量
	*/
	//var (
	//	name     string
	//	age      int
	//	addreass string
	//)
	//name = "符华"
	//age = 20
	//addreass = "惠州市"
	//fmt.Println(name, age, addreass)

	/*
		短变量初始化声明，推导声明写法，可以用 := 自动识别变量类型，全局变量不能用短变量定义
		只能在函数内部使用，不能随便到处声明。由于使用了:=，而不是赋值的=，因此推导声明写法的左值变量必须是没有定义过的变量。
	*/
	//var name = "李四" // 不能先用var声明了变量后，又用 := 去声明
	//name := "张三"
	//age := 20
	//name = "符华"
	//fmt.Println(name, age)
	//fmt.Printf("%T,%T", name, age) // 按照指定的格式输出，这里%T意思的类型，也就是打印这两个变量的类型

	//var num int = 100
	//fmt.Printf("num：%d，内存地址：%p", num, &num) // %d表示数字，%p表示变量内存地址，然后取内存地址用 &变量名
	//num = 200
	//fmt.Printf("num：%d，内存地址：%p", num, &num)

	/*
		变量的交换
	*/
	//var a int = 100
	//var b int = 200
	//b, a = a, b
	//fmt.Println(a, b)

	/*
		自增、自减：自增、自减只能作为表达式使用，而不能用于赋值语句。
	*/
	//a := 1
	//a++
	//a--
	//var b int
	b = a++ // 这里是错误的用法
	//fmt.Println(b)

	/*
		匿名变量，用 _ 表示，本身是一个特殊标识符，被称为空白标识符，表示任何类型都可以赋值给它，但任何赋值都将被抛弃
		使用匿名变量时，只需要在变量声明的地方使用下划线替换即可。
	*/
	//a, _ := test() // 只需要取第一个返回值，所以第二个返回值用匿名变量接收
	//_, b := test() // 只需要取第二个返回值，所以第一个返回值用匿名变量接收
	//fmt.Println(a, b)

	/*
		常量定义
	*/
	//const name1 string = "常量1" // 显式定义
	//const name2 = "常量2"        // 隐式定义
	//const a, b, c = 3.14, "符华", false
	//fmt.Println(name1)
	//fmt.Println(name2)
	//fmt.Println(a, b, c)

	/*
		计数器：iota，每次在const关键字出现时，将被重置为0，const中每新增一行常量声明将使iota计数一次（+1）
	*/
	//const (
	//	a = iota  // 默认iota=0
	//	b         // iota=1
	//	c         // iota=2
	//	d = "hhh" // 输出hhh，但是iota会继续计数，iota=3
	//	e         // 输出hhh，iota=4
	//	f = iota  // iota=5
	//	g = iota  // iota=6
	//	h         // iota=7
	//	i = "hhh" // 输出hhh，iota=8
	//)
	//const (
	//	j = iota // 这里iota将重置为0
	//	k        // iota=1
	//)
	//fmt.Println(a, b, c, d, e, f, g, h, i, j, k)

	//var isFlag bool = true
	//fmt.Printf("%T\n%t\n", isFlag, isFlag)
	//var f1 float64 = 3.14
	//fmt.Printf("%T，%.2f\n", f1, f1) // %f表示输出对应浮点数值，%.2f表示保留两位小数（四舍五入）
	//var str string = "字符串"
	//fmt.Printf("%T，%s\n", str, str) // %s表示输出对应字符串值
	//v1 := 'A'
	//v2 := "A"
	//fmt.Printf("%T，%d\n", v1, v1)
	//fmt.Printf("%T，%s\n", v2, v2)

	/*
		类型转换：基本数据类型的类型转换必须显示转换（强制转换），不能自动转换。
		转换的表达式：T(v)，T表示数据类型，v表示要转换的变量。转换时，被转换的是变量存储的值，变量本身的数据类型并没有发生变化。
	*/
	//a := 5.52
	//b := 3
	//c := int(a)
	//d := float64(b)
	//fmt.Printf("%T\n", a)
	//fmt.Printf("%T\n", b)
	//fmt.Printf("%T\n", c)
	//fmt.Printf("%T\n", d)

	// 其他类型转string
	num1 := 100    // 整型
	num2 := 100.23 // 浮点
	isFlag := true // 布尔
	char := 'a'    // char
	var str string
	str = fmt.Sprintf("%d", num1)
	fmt.Printf("类型=%T，值=%v\n", str, str)
	str = fmt.Sprintf("%f", num2)
	fmt.Printf("类型=%T，值=%v\n", str, str)
	str = fmt.Sprintf("%t", isFlag)
	fmt.Printf("类型=%T，值=%v\n", str, str)
	str = fmt.Sprintf("%c", char)
	fmt.Printf("类型=%T，值=%v\n", str, str)
	// string转其他类型，用 strconv 包下对应的函数，如：ParseBool()、ParseInt()、ParseFloat

	/*
		输入：键盘交互
	*/
	//var x int
	//var y float64
	//fmt.Println("请输入两个数 1、整数 2、浮点数")
	 通过操作地址，将输入的值赋值给变量
	//fmt.Scanln(&x, &y) // 等待键盘输入
	//fmt.Println(x, y)
	//fmt.Println("请输入一个字符串")
	 在io中，可以使用bufio包来读取输入的内容
	//reader := bufio.NewReader(os.Stdin)
	//s1, _ := reader.ReadSlice('\n')
	//fmt.Println("读出的内容为：", s1)

	/*
		局部变量
	*/
	//temp := 100           // func函数体里的局部变量
	//if b := 1; b <= 100 { // 这里定义了一个b变量，只作用于if语句里面
	//	temp := 50        // 这定义的是if语句内的局部变量，到了if语句外是不能使用的
	//	fmt.Println(temp) // 局部变量，就近原则
	//	fmt.Println(b)
	//}
	//fmt.Println(temp) // 这打印的是100
	//fmt.Println(num)

	/*
		switch：每写一个case，不用写break，除非使用了fallthrough穿透
	*/
	//a := false
	//switch a {
	//case false:
	//	fmt.Println("1、case条件为false")
	//	fallthrough // case穿透，不管下一个case的条件是否满足，都会执行
	//case true:
	//	if a == false {
	//		break // 中止case穿透
	//	}
	//	fmt.Println("2、case条件为true")
	//}

	//var score int = 90
	//switch score {
	//case 90:
	//	fmt.Println("A")
	//	fallthrough // case穿透，不管下一个case的条件是否满足，都会执行
	//case 80:
	//	fmt.Println("B")
	//	fallthrough
	//case 50, 60, 70:
	//	fmt.Println("C")
	//default:
	//	fmt.Println("D")
	//}

	/*
		for循环
	*/
	// 计算1到10的数字之和
	//sum := 0
	//for i := 1; i <= 10; i++ {
	//	sum += i
	//}
	//fmt.Println(sum)
	// 无限循环
	//for {
	//	fmt.Println(0)
	//}
	//for j := 0; j < 5; j++ {
	//	for i := 0; i < 5; i++ {
	//		fmt.Print("* ")
	//	}
	//	fmt.Println()
	//}
}

运算符

关于运算符这里，我没有记代码（没啥好记的），所以我在这就直接去某个学习网站截图了🤪

上面几个运算符，没啥好说的，不过关于自增、自减有个地方需要注意，就是：Go 的自增、自减只能作为表达式使用，而不能用于赋值语句。

其他运算符这个关于指针变量，我下一篇会写。下一篇讲函数、函数类型、值传递、引用传递、切片、指针、匿名函数、回调函数、泛型。