Java极速转golang

1. var:e := 100
2. const

const (
	a, b = iota+1, iota+2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
	c, d				  // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
	e, f				  // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4

	g, h = iota * 2, iota *3  // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9 
	i, k					   // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)

3. List item

//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
    
    
	fmt.Println("---- foo3 ----")
	fmt.Println("a = ", a)
	fmt.Println("b = ", b)

	//r1 r2 属于foo3的形参，  初始化默认的值是0
	//r1 r2 作用域空间 是foo3 整个函数体的{}空间
	fmt.Println("r1 = ", r1)
	fmt.Println("r2 = ", r2)
	
	//给有名称的返回值变量赋值
	r1 = 1000
	r2 = 2000

	return
}

4. init和import
   
   5.pointer
   
   6.defer
   压栈的形式。放在最后。
   7.静态数组和动态数组slice

//数组传参要通过动态数组（长度不一致）
func printArray(myArray [4]int) {
    
    
	//值拷贝

	for index, value := range myArray {
    
    
		fmt.Println("index = ", index, ", value = ", value)
	}

	myArray[0] = 111
}


func main() {
    
    
	//固定长度的数组
	var myArray1 [10]int

	myArray2 := [10]int{
    
    1,2,3,4}
	myArray3 := [4]int{
    
    11,22,33,44}

	//for i := 0; i < 10; i++ {
    
    
	for i := 0; i < len(myArray1); i++ {
    
    
		fmt.Println(myArray1[i])	
	}

	for index, value := range myArray2 {
    
    
		fmt.Println("index = ", index, ", value = ", value)
	}

	//查看数组的数据类型
	fmt.Printf("myArray1 types = %T\n", myArray1)
	fmt.Printf("myArray2 types = %T\n", myArray2)
	fmt.Printf("myArray3 types = %T\n", myArray3)

	printArray(myArray3)
	fmt.Println(" ------ ")
	for index, value := range myArray3 {
    
    
		fmt.Println("index = ", index, ", value = ", value)
	}
}

8.slice

func main() {
    
    
	//声明slice1是一个切片，并且初始化，默认值是1，2，3。 长度len是3
	//slice1 := []int{1, 2, 3}

	//声明slice1是一个切片，但是并没有给slice分配空间
	var slice1 []int
	//slice1 = make([]int, 3) //开辟3个空间 ，默认值是0

	//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0
	//var slice1 []int = make([]int, 3)

	//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0, 通过:=推导出slice是一个切片
	//slice1 := make([]int, 3)

	fmt.Printf("len = %d, slice = %v\n", len(slice1), slice1)

	//判断一个silce是否为0
	if slice1 == nil {
    
    
		fmt.Println("slice1 是一个空切片")
	} else {
    
    
		fmt.Println("slice1 是有空间的")
	}

追加元素：append

append满了话会自动开辟cap大小的空间
切片截取：

s := []int{
    
    1, 2, 3} //len = 3, cap = 3, [1,2,3]

	//[0, 2)
	s1 := s[0:2] // [1, 2]

	fmt.Println(s1)

	s1[0] = 100

	fmt.Println(s)
	fmt.Println(s1)

	//copy 可以将底层数组的slice一起进行拷贝
	s2 := make([]int, 3) //s2 = [0,0,0]

	//将s中的值 依次拷贝到s2中
	copy(s2, s)
	fmt.Println(s2)

9.map

//===> 第一种声明方式

	//声明myMap1是一种map类型 key是string， value是string
	var myMap1 map[string]string
	if myMap1 == nil {
    
    
		fmt.Println("myMap1 是一个空map")
	}

	//在使用map前， 需要先用make给map分配数据空间
	myMap1 = make(map[string]string, 10)

	myMap1["one"] = "java"
	myMap1["two"] = "c++"
	myMap1["three"] = "python"

	fmt.Println(myMap1)

	//===> 第二种声明方式
	myMap2 := make(map[int]string)
	myMap2[1] = "java"
	myMap2[2] = "c++"
	myMap2[3] = "python"

	fmt.Println(myMap2)

	//===> 第三种声明方式
	myMap3 := map[string]string{
    
    
		"one":   "php",
		"two":   "c++",
		"three": "python",
	}
	fmt.Println(myMap3)

func printMap(cityMap map[string]string) {
    
    
	//cityMap 是一个引用传递
	for key, value := range cityMap {
    
    
		fmt.Println("key = ", key)
		fmt.Println("value = ", value)
	}
}

func ChangeValue(cityMap map[string]string) {
    
    
	cityMap["England"] = "London"
}

func main() {
    
    
	cityMap := make(map[string]string)

	//添加
	cityMap["China"] = "Beijing"
	cityMap["Japan"] = "Tokyo"
	cityMap["USA"] = "NewYork"

	//遍历
	printMap(cityMap)

	//删除
	delete(cityMap, "China")

	//修改
	cityMap["USA"] = "DC"
	ChangeValue(cityMap)

	fmt.Println("-------")

	//遍历
	printMap(cityMap)
}

10.oop

//声明一种行的数据类型 myint， 是int的一个别名
type myint int

//定义一个结构体
type Book struct {
    
    
	title string
	auth  string
}

func changeBook(book Book) {
    
    
	//传递一个book的副本
	book.auth = "666"
}

func changeBook2(book *Book) {
    
    
	//指针传递
	book.auth = "777"
}

func main() {
    
    
	/*
		var a myint = 10
		fmt.Println("a = ", a)
		fmt.Printf("type of a = %T\n", a)
	*/

	var book1 Book
	book1.title = "Golang"
	book1.auth = "zhang3"

	fmt.Printf("%v\n", book1)

	changeBook(book1)

	fmt.Printf("%v\n", book1)

	changeBook2(&book1)

	fmt.Printf("%v\n", book1)
}

//如果类名首字母大写，表示其他包也能够访问
type Hero struct {
    
    
	//如果说类的属性首字母大写, 表示该属性是对外能够访问的，否则的话只能够类的内部访问
	Name  string
	Ad    int
	level int
}
//结构体的方法
/*
func (this Hero) Show() {
	fmt.Println("Name = ", this.Name)
	fmt.Println("Ad = ", this.Ad)
	fmt.Println("Level = ", this.Level)
}

func (this Hero) GetName() string {
	return this.Name
}

func (this Hero) SetName(newName string) {
	//this 是调用该方法的对象的一个副本（拷贝）
	this.Name = newName
}
*/
func (this *Hero) Show() {
    
    
	fmt.Println("Name = ", this.Name)
	fmt.Println("Ad = ", this.Ad)
	fmt.Println("Level = ", this.level)
}

func (this *Hero) GetName() string {
    
    
	return this.Name
}

func (this *Hero) SetName(newName string) {
    
    
	//this 是调用该方法的对象的一个副本（拷贝）
	this.Name = newName
}

func main() {
    
    
	//创建一个对象
	hero := Hero{
    
    Name: "zhang3", Ad: 100}

	hero.Show()

	hero.SetName("li4")

	hero.Show()
}

继承：

type Human struct {
    
    
	name string
	sex  string
}

func (this *Human) Eat() {
    
    
	fmt.Println("Human.Eat()...")
}

func (this *Human) Walk() {
    
    
	fmt.Println("Human.Walk()...")
}

//=================

type SuperMan struct {
    
    
	Human //SuperMan类继承了Human类的方法

	level int
}

//重定义父类的方法Eat()
func (this *SuperMan) Eat() {
    
    
	fmt.Println("SuperMan.Eat()...")
}

//子类的新方法
func (this *SuperMan) Fly() {
    
    
	fmt.Println("SuperMan.Fly()...")
}

func (this *SuperMan) Print() {
    
    
	fmt.Println("name = ", this.name)
	fmt.Println("sex = ", this.sex)
	fmt.Println("level = ", this.level)
}

func main() {
    
    
	h := Human{
    
    "zhang3", "female"}

	h.Eat()
	h.Walk()

	//定义一个子类对象
	//s := SuperMan{Human{"li4", "female"}, 88}
	var s SuperMan
	s.name = "li4"
	s.sex = "male"
	s.level = 88

	s.Walk() //父类的方法
	s.Eat()  //子类的方法
	s.Fly()  //子类的方法

	s.Print()
}

多态：

//interface本质是一个指针
type AnimalIF interface {
    
    
	Sleep()
	GetColor() string //获取动物的颜色
	GetType() string  //获取动物的种类
}

//具体的类
type Cat struct {
    
    
	color string //猫的颜色
}

func (this *Cat) Sleep() {
    
    
	fmt.Println("Cat is Sleep")
}

func (this *Cat) GetColor() string {
    
    
	return this.color
}

func (this *Cat) GetType() string {
    
    
	return "Cat"
}

//具体的类
type Dog struct {
    
    
	color string
}

func (this *Dog) Sleep() {
    
    
	fmt.Println("Dog is Sleep")
}

func (this *Dog) GetColor() string {
    
    
	return this.color
}

func (this *Dog) GetType() string {
    
    
	return "Dog"
}

func showAnimal(animal AnimalIF) {
    
    
	animal.Sleep() //多态
	fmt.Println("color = ", animal.GetColor())
	fmt.Println("kind = ", animal.GetType())
}

func main() {
    
    

	var animal AnimalIF //接口的数据类型， 父类指针
	animal = &Cat{
    
    "Green"}

	animal.Sleep() //调用的就是Cat的Sleep()方法 , 多态的现象

	animal = &Dog{
    
    "Yellow"}

	animal.Sleep() // 调用Dog的Sleep方法，多态的现象

	cat := Cat{
    
    "Green"}
	dog := Dog{
    
    "Yellow"}

	showAnimal(&cat)
	showAnimal(&dog)
}

//interface{}是万能数据类型
func myFunc(arg interface{
    
    }) {
    
    
	fmt.Println("myFunc is called...")
	fmt.Println(arg)

	//interface{} 改如何区分 此时引用的底层数据类型到底是什么？

	//给 interface{} 提供 “类型断言” 的机制
	value, ok := arg.(string)
	if !ok {
    
    
		fmt.Println("arg is not string type")
	} else {
    
    
		fmt.Println("arg is string type, value = ", value)

		fmt.Printf("value type is %T\n", value)
	}
}

type Book struct {
    
    
	auth string
}

func main() {
    
    
	book := Book{
    
    "Golang"}

	myFunc(book)
	myFunc(100)
	myFunc("abc")
	myFunc(3.14)
}

11.reflect
typeof valueof
12.tag

type resume struct {
    
    
	Name string `info:"name" doc:"我的名字"`
	Sex  string `info:"sex"`
}

func findTag(str interface{
    
    }) {
    
    
	t := reflect.TypeOf(str).Elem()

	for i := 0; i < t.NumField(); i++ {
    
    
		taginfo := t.Field(i).Tag.Get("info")
		tagdoc := t.Field(i).Tag.Get("doc")
		fmt.Println("info: ", taginfo, " doc: ", tagdoc)
	}
}

func main() {
    
    
	var re resume

	findTag(&re)

}

type Movie struct {
    
    
	Title  string   `json:"title"`
	Year   int      `json:"year"`
	Price  int      `json:"rmb"`
	Actors []string `json:"actors"`
}

func main() {
    
    
	movie := Movie{
    
    "喜剧之王", 2000, 10, []string{
    
    "xingye", "zhangbozhi"}}

	//编码的过程  结构体---> json
	jsonStr, err := json.Marshal(movie)
	if err != nil {
    
    
		fmt.Println("json marshal error", err)
		return
	}

	fmt.Printf("jsonStr = %s\n", jsonStr)

	//解码的过程 jsonstr ---> 结构体
	//jsonStr = {"title":"喜剧之王","year":2000,"rmb":10,"actors":["xingye","zhangbozhi"]}
	myMovie := Movie{
    
    }
	err = json.Unmarshal(jsonStr, &myMovie)
	if err != nil {
    
    
		fmt.Println("json unmarshal error ", err)
		return
	}

	fmt.Printf("%v\n", myMovie)
}

13.goroutine
协程








早期：





m1完成后睡眠/销毁

//子goroutine
func newTask() {
    
    
	i := 0
	for {
    
    
		i++
		fmt.Printf("new Goroutine : i = %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

//主goroutine
func main() {
    
    
	//创建一个go程 去执行newTask() 流程
	go newTask()

	fmt.Println("main goroutine exit")

	/*
		i := 0
		for {
			i++
			fmt.Printf("main goroutine: i = %d\n", i)
			time.Sleep(1 * time.Second)
		}
	*/
}

14.channel
goroutine间的通信机制
无缓冲：

func main() {
    
    
	//定义一个channel
	c := make(chan int)

	go func() {
    
    
		defer fmt.Println("goroutine结束")

		fmt.Println("goroutine 正在运行...")

		c <- 666 //将666 发送给c
	}()

	num := <-c //从c中接受数据，并赋值给num

	fmt.Println("num = ", num)
	fmt.Println("main goroutine 结束...")
}

有缓冲：

func main() {
    
    
	c := make(chan int, 3) //带有缓冲的channel

	fmt.Println("len(c) = ", len(c), ", cap(c)", cap(c))

	go func() {
    
    
		defer fmt.Println("子go程结束")

		for i := 0; i < 4; i++ {
    
    
			c <- i
			fmt.Println("子go程正在运行, 发送的元素=", i, " len(c)=", len(c), ", cap(c)=", cap(c))
		}
	}()

	time.Sleep(2 * time.Second)

	for i := 0; i < 4; i++ {
    
    
		num := <-c //从c中接收数据，并赋值给num
		fmt.Println("num = ", num)
	}

	fmt.Println("main 结束")
}

关闭channel

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

	go func() {
    
    
		for i := 0; i < 5; i++ {
    
    
			c <- i
			//close可以关闭一个channel
			close(c)
		}
	}()

	for {
    
    
		//ok如果为true表示channel没有关闭，如果为false表示channel已经关闭
		if data, ok := <-c; ok {
    
    
			fmt.Println(data)
		} else {
    
    
			break
		}
	}

	fmt.Println("Main Finished..")
}

channel不像⽂件⼀样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结
束range循环之类的，才去关闭channel；
关闭channel后，⽆法向channel 再发送数据(引发 panic 错误后导致接收⽴即返回零值)；
关闭channel后，可以继续从channel接收数据；
对于nil channel，⽆论收发都会被阻塞。
range：

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

	go func() {
    
    
		for i := 0; i < 5; i++ {
    
    
			c <- i
		}

		//close可以关闭一个channel
		close(c)
	}()

	//可以使用range来迭代不断操作channel
	for data := range c {
    
    
		fmt.Println(data)
	}

	fmt.Println("Main Finished..")
}
	·1噢、】p0-q['
	]\
	Ÿvm,
	]=-0q1	`qA
	=-0		A在≥÷？。，b v 	

select:
单流程下⼀个go只能监控⼀个channel的状态，select可以完成
监控多个channel的状态

func fibonacii(c, quit chan int) {
    
    
	x, y := 1, 1

	for {
    
    
		select {
    
    
		case c <- x:
			//如果c可写，则该case就会进来
			x = y
			y = x + y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

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

	//sub go
	go func() {
    
    
		for i := 0; i < 10; i++ {
    
    
			fmt.Println(<-c)
		}

		quit <- 0
	}()

	//main go
	fibonacii(c, quit)
}