java转go 翱翔之路(一)基础语法:变量声明,匿名函数,结构体,函数,map

1.Go语言

1.命令

1.1 查看版本号

go version

1.2 查看安装信息

go env

2.资料

2.1 官方文档

https://studygolang.com/pkgdoc

2.2 md 语法

https://www.appinn.com/markdown/

2.3 go环境的安装

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

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

2.4注意事项

1.把liteIDEA放到go安装的根目录下
2.ctrl+F7 编译运行

3.helloWorld函数

package main

import "fmt"

func main() {
	fmt.Println("hello go")
}

2.语法

2.1

2.1声明变量

var a int
fmt.Println("a = ",a)

2.1.1 声明变量特殊语法（常用）

	var a int = 40
	a = 30

	fmt.Println("a = ", a)
//c :=30 == var a int = 40 常用
	c := 30
	fmt.Printf("param type is %T\n", c)

2.1.2 两个变量互换位置

	i, j := 10, 20
	i, j = j, i
	fmt.Printf("i= %d,j = %d\n", i, j)

2.1.3 匿名函数互换位置

//匿名函数 _函数配合函数 返回值使用
	q, w := 10, 20
	q, _ = w, q
	fmt.Printf("q= %d\n", q)

2.1.4 函数调用

//go函数可以返回多个值
func test() (a, b, c int) {
	return 1, 2, 3
}
//调用函数
	var c, d, e int
	c, d, e = test() //return 1,2,3

2.1.5 匿名函数调用

	//匿名函数
	_, d, _ = test() //return 1,2,3
	fmt.Printf("c =%d ， d =%d ,e =%d\n", c, d, e)

2.1.6 常量关键字 const

	const a int = 10
	fmt.Printf("a =%d", a)
	const b = 11.2

2.1.7 枚举iota

2.1.7.1 iota常量自动生成器，每个一行，自动累加1

2.1.7.2 iota给常量赋值使用

	//1.iota常量自动生成器，每个一行，自动累加1
	//2.iota给常量赋值使用
	const (
		a = iota //0
		b = iota //1
		c = iota //2
	)
	fmt.Printf("a =%d,b =%d ,c =%d", a, b, c)

2.1.7.3 iota遇到const，重置为0

//3.iota遇到const，重置为0
	const d = iota //0
	fmt.Printf("d =%d\n", d)

2.1.8 字符串

	package main

import "fmt"

func main() {
	var str1 string
	str1 = "abc"
	fmt.Println("str1 = ", str1)
	//自动推导类型
	str2 := "make"
	fmt.Println("str2 =", str2)
	//内建函数 长度
	fmt.Println("len(str2) =", len(str2))

}

2.1.9 复数

var t complex128 //声明
	t = 2.1 + 3.14i
	fmt.Println("t =", t)
	//自动推导类型
	t2 := 3.3 + 4.4i
	fmt.Printf("t2 type is %T\n", t2)

	//通过内建函数，取实部和虚部
	fmt.Println("real t2 = ", real(t2))

2.1.10 类型别名

	type bigint int64
	var a bigint
	type (
		long int64
		char byte
	)
	var b long = 11
	var ch char = 'a'
	fmt.Printf("b = %d, ch = %c\n", b, ch)

2.1.11 if类型

	//if类型 初始化变量 当a=10时,跳转到括号
	if a := 10; a == 10 {
		fmt.Println("a =", 10)
	}

2.1.11 range类型(迭代)

	for i := 0; i < len(str); i++ {
		fmt.Printf("str[%d] = %c\n", i, str[i])
	}
	fmt.Println("------")
	//i是下标
	for i, data := range str {
		fmt.Printf("str[%d]=%c\n", i, data)
	}
	fmt.Println("------")
	for i := range str {
		fmt.Printf("str[%d]=%c\n", i, str[i])
	}
	for i, _ := range str {
		fmt.Printf("str[%d]=%c\n", i, str[i])
	}

2.1.12 goto类型

	//End
	fmt.Println("1111")
	goto End
	fmt.Println("222")
End:
	fmt.Println("333")

##2.2

2.2.1函数定义(无返回值)

func Myfunc() {
	a := 111
	fmt.Println("无参= ", a)

}
func Myfunc1(a int) {

	fmt.Println("有参= ", a)

}
func Myfunc2(a int, b int) {

	fmt.Printf("a = %d,b=%d\n", a, b)
}
func Myfunc3(a string, b int, c float32) {

	fmt.Printf("a = %d,b=%d,c = %d \n,", a, b, c)
}

func main() {
	Myfunc()
	Myfunc1(222)
	Myfunc2(333, 444)
	Myfunc3("555", 666, 777.1)
}

2.2.2函数定义(有返回值)

//有返回值
func Myfunc2(a int, b int) (max int, mix int) {
	max = a
	mix = b

	return //有返回值的函数,必须通过return返回
}

func main() {
	var a int
	_, a = Myfunc2(333, 444)
	fmt.Println("a=", a)

}

2.2.3函数类型

func addF(a int, b int) int {
	return a + b
}
func minF(a int, b int) int {
	return a - b
}

//定义函数类型
//FuncType是一个函数类型
type FuncType func(int, int) int //没有函数名字 没有{}

func main() {

	var result int
	var TestF = FuncType
	TestF = minF
	result = TestF(20, 10)
	fmt.Println("a=", result)
}

2.2.4函数类型(回调函数,多态)

func add(a int, b int) int {
	return a + b
}

//
func addF(a int, b int, dtest FuncType) (result int) {

	result = dtest(a, b)

	return
}

//定义函数类型
//FuncType是一个函数类型
type FuncType func(int, int) int //没有函数名字 没有{}

func main() {
	a := addF(1, 1, add)
	fmt.Println("a =", a)
}

2.2.5匿名函数+闭包

func main() {
	a := 10
	b := 20
	//1.定义匿名函数
	f1 := func() {
		fmt.Println("a = ", a)
		fmt.Println("b = ", b)

	}
	//2.匿名函数类型
	type FuncType1 func()
	var f2 FuncType1
	f2 = f1
	f2()

	fmt.Println("a =", a)
	//3.定义匿名函数
	 func() {
		fmt.Println("a = ", a)
		fmt.Println("b = ", b)

	}()//()表示调用此函数
	//4 有参匿名函数
	f4 := func(a,b int) {
		fmt.Println("a = ", a)
		fmt.Println("b = ", b)

	}
	f4(4,5)
	//5.无名匿名带参数
	func(a,b int) {
		fmt.Println("a = ", a)
		fmt.Println("b = ", b)

	}(5,6)//()表示调用此函数
	//6.匿名函数有参有返回值
	x,y = func(i,j int)(max,min int){
		max = i
		min = j
		return	
	}(10,20)
	
}

2.2.5闭包 匿名函数 变量

func test2() func() int {
	var x int //没有初始化,值为0
	return func() int {
		x++
		return x * x
	}
}

func main() {
	f := test2()
	//闭包-不关心变量和常量是否已经超出作用于
	//只要闭包还在使用它,这些变量就还存在
	fmt.Println(f()) //1
	fmt.Println(f()) //4
	fmt.Println(f()) //9
}

2.2.6 defer的使用

//defer延迟调用 main函数结束前调用
	defer fmt.Println("bbb")
	fmt.Println("aaaaa") 

//有多个defer语句,则是 先进后出 哪怕函数出错 依旧会执行
defer fmt.Println("111")
defer fmt.Println("222")
defer fmt.Println("333")

//匿名函数表示,把变量赋值过去 但是没有调用
	defer func(a,b int){
		fmt.Printf("a = %d ,b = %c\n",a,b)
	}(10,20)

2.2.7 获取命令行参数

func main() {
	//要先go build 成 exe
	list := os.Args

	n := len(list)
	fmt.Println("n =", n)

	for i := 0; i < n; i++ {
		fmt.Printf("list[%d] = %s\n", i, list[i])
	}
    for i, data := range list {
    fmt.Printf("list[%d] = %s\n", i, data)
    }
}

2.2.8 变量

1.不同作用域可以有同名变量
2.使用变量的原则,就近原则

2.2.9 导入导出包

//给包起别名
import io "fmt"
io.Println("起别名")
//忽略包
import _ "fmt"

2.2.10 init函数

先执行 init函数 在执行main函数

2.3 复合类型

2.3.1声明变量 指针类型

	//变量两含义 1内存 2地址
	var num int = 10
	fmt.Printf("a = %d\n ", num)
	fmt.Printf("a = %v\n ", &num)

	//保存变量的地址 需要指针类型
	var p *int
	p = &num
	fmt.Printf("p = %v\n ,&a = %v\n ", p, &num)

2.3.2默认值 nil new函数

	var p *int
	p = nil
	fmt.Println("平= ", p)
	//
	p := new(int)
	*p = 777

2.3.3数组定义赋值

func main() {
	var arr [20]int

	for i := 0; i < len(arr); i++ {
		arr[i] = i + 1
		fmt.Printf("arr[%d] = %d\n", i, arr[i])

	}
	
	//数组定义 置值,其他值为0
	arr1 := [5]int{1, 2, 3}
	//指定位置赋值
	arr2 := [5]int{2: 1, 3: 4}
	fmt.Println(arr2)

}

2.3.4 随机数

import "fmt"
import "time"
import "math/rand"
func main() {
	//设置随机数种子
	rand.Seed(time.Now().UnixNano()) //当前的系统执行时间

	for i := 0; i < 5; i++ {
		fmt.Println("rand =", rand.Intn(100))
	}

}

2.3.5数组指针

import "fmt"
import "time"
import "math/rand"
//数组指针
//*p 代表指针所指向的内存,就是实参
func modify(p *[5]int) {

	//p[0] = 66
	(*p)[0] = 666
}

2.3.6切片spilt

func main() {

	a := []int{1, 2, 3, 54, 5, 7, 89, 6}
	//[low:high:max]
	//下标起点  下标终点  (左闭右开) 容量(max-low)
	s := a[0:3:5]
	fmt.Println("s = ", s)         //[1 2 3]
	fmt.Println("s len =", len(s)) //长度 3
	fmt.Println("s cap =", cap(s)) //容量 5
    //创建切片
	b := []int{}
	//给切片追加一个成员
	b=append(b,11)
    //不写默认0 从0开始取3个元素.容量为 5-0
    s := a[:3:5]
 
}

2.3.6切片切切片

   //切片切切片
    a := []int{1, 2, 3, 4, 5, 7, 8, 9}
	s1 := a[1:3] //[2,3]
	fmt.Println("s1 =", s1)
	s2 := s1[1:5] //[3,4,5,7]
	fmt.Println("s1 =", s2)

2.3.7 copy函数

a := []int{1, 2, 3, 4, 5}
	b := []int{6, 7, 8, 9, 10, 11}
	copy(a, b)

	fmt.Println("a =", a) //{6, 7, 8, 9, 10}
	fmt.Println("b =", b) //{6, 7, 8, 9, 10,11}

2.3.7 map

2.3.7.1 map的定义

func deleMap(mapV map[int]string) {
	delete(mapV, 1)
}

	//创建map
	var map1 map[int]string
	fmt.Println("a =", map1) //{6, 7, 8, 9, 10}
	//通过make创建
	map2 := make(map[int]string)
	map2[1] = "make"
	map2[2] = "sss"
	//定义初始化
	map3 := map[int]string{1: "a", 2: 'b'}
	//删除
	delete(map3, 1)
	fmt.Println(map3)
	//定义函数
	
	deleMap(map3)

2.3.7.2 map的循环

	//定义初始化
	map3 := map[int]string{1: "a", 2: "b"}
	//循环
	for key, value := range map3 {
		fmt.Printf("%d =====>%s\n", key, value)
	}
	//判断一个Key值是否存在
	//第一个返回值为key所对应的value
	value, ok := m[1]
	if ok == true {

		fmt.Printf("m[1] =", value)
	} else {
		fmt.Printf("key不存在")
	}

2.3.8 结构体

type Student struct {
	id   int
	name string
	sex  byte
	age  int
	addr string
}

func main() {

	
	var s1 Student = Student{1, "make", 'm', 20, "背景"}
	fmt.Println(s1)//{1 make 109 20 背景}
	//指定声明
	s2 := Student{name: "make", addr: "背景"}
	fmt.Println(s2)//{0 make 0 0 背景}
	//声明指针变量
	s3 := &Student{name: "make", addr: "背景"}
	fmt.Println(s3)//&{0 make 0 0 背景}
	var s4 *Student = &Student{1, "make", 'm', 20, "背景"}
	fmt.Printf("s4 type= %T\n", s4)//s4 type= *main.Student
	fmt.Println(s4)//&{1 make 109 20 背景}
    
    //先定义在赋值
	var stu1 Student
	stu1.id = 1
	stu1.name = "mike"
	stu1.sex = '5'
	fmt.Println(stu1) //{1 mike 53 0 }
	//new申请
	stu2 := new(Student)
	stu2.id = 1
	stu2.name = "mike"
	stu2.sex = '5'
	fmt.Println(stu2) //&{1 mike 53 0 }

}

2.3.9 可见性

如果想使用别的包的函数,结构体类型,结构体成员,函数名,类型名,结构体成员变量名
首字母必须大写,可见

如果首字母小写,只能能在同一个包里使用

​
​

通用

1.fmt.Sprintf (格式化输出)

           %v	   按值的本来值输出
　　　　　　%+v	   在 %v 的基础上，对结构体字段名和值进行展开       
　　　　　　%#v 	   输出 Go 语言语法格式的值
　　　　　　%T	 　输出 Go 语言语法格式的类型和值
　　　　　　%% 	    输出 %% 本体
　　　　　　%b	    整型以二进制方式显示
　　　　　　%o	    整型以八进制方式显示
　　　　　　%d	    整型以十进制方式显示
　　　　　　%x	    整型以 十六进制显示
　　　　　　%X	    整型以十六进制、字母大写方式显示
　　　　　　%U	     Unicode 字符
　　　　　　%f	     浮点数
　　　　　　%p	     指针，十六进制方式显示

​
​
​
​

​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
53 0 }

}

### 2.3.9 可见性
如果想使用别的包的函数,结构体类型,结构体成员,函数名,类型名,结构体成员变量名
**首字母必须大写,可见**

如果首字母小写,只能能在**同一个包里使用**


















​	
​	
# 通用
## 1.fmt.Sprintf (格式化输出)

       %v	   按值的本来值输出

%+v 在 %v 的基础上，对结构体字段名和值进行展开
　　　　　　%#v 输出 Go 语言语法格式的值
　　　　　　%T 　输出 Go 语言语法格式的类型和值
　　　　　　%% 输出 %% 本体
　　　　　　%b 整型以二进制方式显示
　　　　　　%o 整型以八进制方式显示
　　　　　　%d 整型以十进制方式显示
　　　　　　%x 整型以 十六进制显示
　　　　　　%X 整型以十六进制、字母大写方式显示
　　　　　　%U Unicode 字符
　　　　　　%f 浮点数
　　　　　　%p 指针，十六进制方式显示

​	
​	
​	
​	
	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​	
​