来Javaer，学学go吧(一)

	Java的主要用途和应用场景：

 用途一：服务器后端系统开发(web后端、微服务后端支付系统、业务系统、管理后台，各种后台交互的接口服务)。
  
  用途二：大数据框架的底层实现和Java的API支持。(Hadoop)。

 用途三：其它中间件的底层开发。(Tomcat、RocketMq、Hbase、Kafka(部分)、SpringCloud，Dubbo...)。

	Java语言有什么优势和特点呢？

 *.做服务端系统性能高。

 *.有虚拟机，跨平台。

 *.功能强大，支持的类库多，生态圈类库多，开发框架和工具更易找。

 *.市场占有率高，约60%的中国程序员都是做Java相关的工作。

Go语言是Google内部公司大佬开发的，主要起因于Google公司有大量的C程序项目，但是开发起来效率太低，维护成本高，于是就开发了Go语言来提高效率，而且性能只是差一点。

（Go是2007年开始研发，2009推出发布）

	来看一下Go语言与Java的差异之处：

 *.无虚拟机，不跨平台(这里的平台指操作系统)(可以运行多个平台，每个平台打不同的二进制程序包)，需要打包编译成对应服务器操作系统版本(windows/linux)的可执行程序(比如windows是exe)。(注:说go跨平台的是指32位和64位相同操作系统之间的跨平台)

 *.因为Go程序直接打包成操作系统可执行的文件，没有虚拟机在中间转换的一层，所以理论上执行效率会更高（理论上更高，实际情况需具体分析)。

 *.相比Java的语言和代码编写风格，Go更简洁，可以用更少的代码实现同样的功能。

 *.Go语言底层也是C实现的，又做了高并发的设计(Java出生时(1995)还没有多核cpu,所以他的并发支持后来添加上去的,Go(2009)出生时已经有了多核cpu的电脑，它在设计语言时就考虑了充分利用多核cpu(英特尔2005首次推出多核)的性能)，所以性能高，高并发的支持(高并发支持其中指的一个就是充分利用多核cpu的性能资源，比如go程序默认使用所有cpu(除非自己设置使用多少))也好。

 *.天然的适用一些特定系统的开发，比如区块链类系统(如以太坊底层系统、以太坊上层应用程序)，云计算和容器（Docker，K8s底层都是go开发的）开发的(大公司自研运维管理项目也大多是用go做底层的开发)，网络编程(类似于java的Netty)。

	计算机编程语言按照运行的方式可以分为编译型编程语言和解释型编译语言。

    举一个例子，你要教别人一门沟通交流的语言，比如英语。

    编译型的教的方式就是录(这里的录相当于计算机中把程序编译成二进制可执行文件)一个视频课程，语音课程，把每一句英语发音录下来，这样学生学的时候只要播放你的录音，然后跟着读就行，你只需要录制一次，学生就可以无数次听。

	 解释性的教的方式就是你亲自到学生家里给他补习，你当面教他，你读(读相当于每次执行都重新用解释器解释一遍)一句他学一句，

	  这两种教学方式还有一个差别，你录(编译)视频语音教他，你录的英语他就只能学英语，空间环境一变，他现在要去日本，要学日语，你的视频语音教程因为已经录好了，是英语类型(英语类型类比操作系统类型)的，所以，你就得再录一套日语的语音教程。

	 而现场教他，你也会日语的话，你只需要读(读相当于解释器解释)日语给他听，让他学就行了，是不用考虑语言环境(操作系统类型环境)不同的问题的。

	 现在再来看编程语言，程序执行有两种方式，一种是编译成操作系统可执行的二进制可执行程序，这样相当于编译一次，之后每次执行都不用再编译了，但是因为不同操作系统对于二进制文件的执行规范不同，不同的操作系统你要编译成不同的可执行文件。

	 解释型语言就是多了一个解释器，解释器我们可以类比为一个老师，你执行一行代码我们类比为学一句话的读音，解释器解释一句，就是老师先读一句，你跟着才能读一句，也就是解释器每解释一行代码为可运行的代码，操作系统执行一行代码，这样的话每次执行都需要解释器重新解释一遍，执行几次就得解释几次。

	Go是编译型的语言，运行在不同的平台需要打包成不同操作系统类型下的可执行文件。

    Java是半编译，半解释型语言。编译是指他的代码都会编译成class类型的文件，class类型的文件只需要编译一次，可以在不同的操作系统的Java虚拟机上执行 ，半解释是指在Java虚拟机中，他还是需要一句一句的将class的二进制代码解释成对应操作系统可执行的代码。

 *.和Java一样，Go语言最多的应用场景就是服务器后端系统的开发，包括Web后端，微服务后端接口。

 *.Go非常适用需要高性能高并发的网络编程，这里的网络编程是指不需要界面，底层只是用Socket相互传输数据的系统，类似于Java中Netty的用途。

 *.一些云计算容器，比如Docker，K8s，底层就是Go语言开发的，也可以用做底层自研运维项目的开发。

 *.一些游戏系统的开发，可以用Go语言。
 
 *.区块链的一些底层软件和一些应用软件。(区块链程序的第一开发语言)
 

	直接BOSS直聘看哪些公司招，招的是干什么系统开发的。

	这是腾讯的一个岗位。

					1.bin	（用于存放项目编译后的可执行文件）

					2.pkg     (用于存放类库文件，比如.a结尾的包模块)

					3.src    （用于存放项目代码源文件）	

vi /etc/profile
#添加如下 目录可以灵活修改
export GOPATH=/pub/go/gopath
//立即刷新环境变量生效
source /etc/profile

vi   ~/.bash_profile

#添加如下 目录可以自己灵活修改
export GOPATH=/home/user/local/soft/go/gopath
//立即刷新环境变量生效
source vi   ~/.bash_profile

GO中文社区SDK下载地址：https://studygolang.com/dl

go1.14

我们用1.14版就可以，因为1.13后才完全支持Module功能。

有两种安装模式，一种是压缩包解压的方式，一种是图形化安装。

 推荐使用windows图形安装傻瓜式安装，windows图形安装下载这个

 https://studygolang.com/dl/golang/go1.14.6.windows-amd64.msi

 linux安装如下：

	后续补上。。。

//主程序必须是写成main包名
package main

//导入别的类库
import "fmt"    

//全局常量定义
const  num = 10
  
//全局变量定义
var name string = "li_ming"

//类型定义
type P struct {

}
  
//初始化函数
func init() {

}

//main函数:程序入口
func main() {
 fmt.Printf("Hello World!!!");
}

//包名
package my_package;
       
//导入包中的类
import java.io.*；

public Class MainTest{ 
 //main方法:程序入口
    public void static main(String[] args) {
 
 }
}
//people类
Class People {
 //成员变量
 public String name;
 public int age;
            
 //成员方法
 public void doSomething() {
             
 }
    
}

最常用的有三种：

Visual Studio Code(VS Code) 微软开发的一款Go语言开发工具。

LiteIDE 是国人开发的Go语言开发工具。

GoLand 这个非常好用，和Java中的IDEA是一家公司。(推荐使用)

MyEclipse,Eclipse

IntelliJ IDEA(大多数用这个)。

Go中文API文档地址：
https://studygolang.com/pkgdoc

        Go                                              Java         

IO流操作：      bufio/os                                     java.lang.io
字符串操作：      strings                                    java.lang.String
容器           container(heap/list/ring)                  java.lang.Collection
锁               sync                                       juc
时间              time                                      java.time/java.lang.Date
算数操作          math                                       java.math
底层Unsafe       unsafe                                     unsafe类       

1.布尔型：关键字【bool】： true   false
2.有符号整形：头一位是代表正负
            int   默认整形   4或8字节             32位或64位     
            int8             1字节                     8位
            int16            2字节                     16位
            int32            4字节                     32位
            in64             8字节                     64位
         【int是32还是64位取决于操作系统的位数，现在电脑一般都是64位的了，所以一般都是64位】
3.无符号整形
            uint             4或8字节            32位或64位
            uint8             1字节                     8位
            uint16            2字节                     16位
            uint32            4字节                     32位
            uint64            8字节                     64位
4.浮点型
            注：go语言没有float类型，只有float32和float64。
            float32           32位浮点数  
            float64           64位浮点数
5.字符串
            string
6. byte     等同uint8，只是类似于一个别名的东西
   rune     等同int32  只是一个别名，强调表示编码概念对应的数字

注:这里简单列举一下
指针   Pointer
数组   Array[]
结构体  struct
进程管道：channel 
函数    func
切片   slice
接口   interface
哈希    map

byte

short

int

long

float

double

boolean

char

package main

import(
   //包含print函数
   "fmt"
)
func main() {
   //var  变量名  变量类型 = 变量值
   var name string = "xiao_ming"
   //方法内部可以直接使用 【 变量名 := 变量值 】 赋值，方法外不可以
   name2:="xiao_hong"
   fmt.Println("name = ",name)
   fmt.Println("name2 = ",name2)
}

public class MyTest {
    public static void main(String[] args) {
        //变量类型  变量名 = 变量值
        String name = "steven";
        int i = 10;
        System.out.println("name ="+name);
        System.out.println("i ="+i);
    }
}

go中的常量和java中的常量含义有一个本质的区别：
go中的常量是指在编译期间就能确定的量(数据)，
而java中的常量是指被赋值一次后就不能修改的量(数据)。
所以两者不一样，因为Java中的常量也是JVM跑起来后赋值的，只不过不允许更改；
go的常量在编译后就确实是什么数值了。

package main

import(
   //包含print函数
   "fmt"
)
func main() {
   //const  常量名  常量类型 = 常量值   显示推断类型
   const name string = "const_xiao_ming"
   //隐式推断类型
   const name2 ="const_xiao_hong"
   fmt.Println("name = ",name)
   fmt.Println("name2 = ",name2)
}

public class MyTest {
    //【访问修饰符】 【静态修饰符】final修饰符   常量类型   常量名 =  常量值；
    public static final String TAG = "A";    //一般设置为static静态
    public static void main(String[] args) {
        System.out.println("tag= "+TAG);
    }
}

Go方法内的赋值符号可以用  := ,也可以用 =,方法外只能用 = 。
例如:

package main

import(
   //包含print函数
   "fmt"
)

//方法外只能用 = 赋值
var my_name  string = "my_name"
var my_name2 = "my_name2"
//my_name3:="my_name3"    不在方法内，错误

func main() {
   fmt.Println("name = ",my_name)
   fmt.Println("name2 = ",my_name2)
}

Go支持多变量同时赋值：

package main

import(
   //包含print函数
   "fmt"
)

func main() {
   //多变量同时赋值
   var name,name2 = "li_ming","xiao_hong"
   fmt.Println("name = ",name)
   fmt.Println("name2 = ",name2)
}

Go的丢弃赋值

package main

import(
   //包含print函数
   "fmt"
)

func main() {
   //丢弃赋值    把 1和2丢弃 只取3
   //在必须一次取两个以上的值的场景下，又不想要其中一个值的时候使用，比如从map中取key,value
   var _,_,num = 1,2,3
   fmt.Println("num = ",num)
}

public class MyTest {
    public static void main(String[] args) {
        //直接用 = 赋值
        String name = "xiao_ming";
        int i = 10;
        System.out.println("name ="+name);
        System.out.println("i ="+i);
    }
}

Go中的注释写法和Java中的基本一样。
例如：
//单行注释,两者相同
/*
    Go的多行注释
*/
/**
	Java多行注释
*/

	------------------------------------a.go

    ------------------------------------b.go

    ------------------------------------c.go

//这里的ui，也就是package后面的名称尽量和包文件夹的名称一致，不一致也可以
package ui

//相关方法和业务

func main() {
   
}
//启动游戏UI
func StartGameUI() {

}

//游戏主程序
package main

//这里的ui是com.ababa.niu.ui的最后一层文件夹名
import "ui"

//相关方法和业务

func main() {
 //这里的ui不是文件夹名，而是之前a.go程序中package后面写的包名
 ui.StartGameUI()
}

package ui

import "fmt"

func main() {
   //这里的P是大写
   //所有调用别的包下的函数，都是首字母大写
   fmt.Printf("aa")
}
//这里的Person的首字母P也是表示外部程序导入该包后可以使用此Person类
type Person struct{

}
//这里的D同上
var Data string = "li_ming"

Java的编译文件是.class结尾,多个.class打成的一个可执行文件是.jar结尾,.jar不能直接在windows和linux上执行,得用java命令在JVM中执行。

Go语言的程序文件后缀为.go,有main包main函数的,.go文件打包成二进制对应操作系统的可执行程序,如windows上的.exe结尾的可执行程序。

Java的类库会以.jar结尾，Go语言非main包没有main函数的程序编译打包会打成一个类库，以.a结尾,也就是说Go语言的类库以.a结尾。

Go的类库如下:
            包名.a     
            my_util.a
注：my_util是最顶层文件夹名，里面包含着一个个程序文件。

Go中的if和Java中的if使用相同，只不过是把小括号给去掉了。       

package main

import (
   "fmt"
)
func main() {
   /*
      单分支结构语法格式如下:
         if 条件判断 {
            //代码块
         }
   */

   var num int

   fmt.Printf("请输入数字")
   fmt.Scan(&num)

   if num > 10 {
      fmt.Println("您输入的数字大于10")
   }
}

package main

import (
   "fmt"
)
func main() {
   /*
      if else分支结构语法格式如下:
         if 条件判断 {
            //代码块
         } else {
            //代码快2
         }
   */

   var num int

   fmt.Printf("请输入数字")
   fmt.Scan(&num)

   if num > 10 {
      fmt.Println("您输入的数字大于10")
   } else {
      fmt.Println("您输入的数字不大于10")
   }
}

package main

import (
   "fmt"
)
func main() {
   /*
      if else分支结构语法格式如下:
         if 条件判断 {
            //代码块
         } else if 条件判断{
            //代码块2
         } else {
            //代码块3
         }
   */

   var num int

   fmt.Printf("请输入数字")
   fmt.Scan(&num)

   if num > 10 {
      fmt.Println("您输入的数字大于10")
   } else if num == 10{
      fmt.Println("您输入的数字等于10")
   } else {
      fmt.Println("您输入的数字小于10")
   }
}

package main

import (
   "fmt"
)
func main() {
   var a = "xiao_ming"
   switch a {
   case "xiao_ming":
      fmt.Println("Hello!XiaoMing")
   case "xiao_hong":
      fmt.Println("Hello!XiaoHong")
   default:
      fmt.Println("No!")
   }
}

package main

import (
   "fmt"
)
func main() {
 
   var name = "xiao_ming"
   var name2 = "xiao_hong"
   switch name {
   //li_ming或xiao_hong 均进入此
   case "xiao_ming", "xiao_hong":
      fmt.Println("xiao_ming and xiao_hong")
   }

   switch name2 {
   case "xiao_ming", "xiao_hong":
      fmt.Println("xiao_ming and xiao_hong")
   }
}

package main

import (
   "fmt"
)
func main() {
   var num int = 11
   switch{
      case num > 10 && num < 20:
         fmt.Println(num)
   }
}

package main

import (
   "fmt"
)
func main() {
   var num = 11
   switch {
   case num == 11:
      fmt.Println("==11")
      fallthrough
   case num < 10:
      fmt.Println("<12")
   }
}

package main

import (
"fmt"
)

func main() {
   for i := 1; i < 10; i++ {
      fmt.Println(i)
   }
}

package main

import (
   "fmt"
)

func main() {
   i := 0
   //省略另外两项，相当于java中的while
   for i < 3 {
      i++
   }
   //break用法相同
   for i == 3 {
      fmt.Println(i)
      break
   }
}

package main

func main() {
   for {

   }

   for true {

   }

}

package main

import "fmt"

func main() {
   var data [10]int = [10]int{1,2,3,4,5,6,7,8,9,10}
   for  i, num := range data {
      fmt.Println(i,num)
   }
}

package main

import "fmt"

func main() {

   //goto可以用在任何地方，但是不能跨函数使用
   fmt.Println("start")

   //go to的作用是跳转，中间的语句不执行，无条件跳转
   goto my_location //goto是关键字， my_location可以自定义，他叫标签

   fmt.Println("over")
   my_location:
   fmt.Println("location")

var 数组名 [数组长度]数组类型  = [数组长度]数组类型{元素1，元素2...}

package main

import "fmt"
//全局
var my_arr [6]int
var my_arr_1 [3]int = [3]int{1,2,3}
func main() {
   //方法内：
   this_arr := [2]int{1, 2}
   fmt.Println(my_arr)
   fmt.Println(my_arr_1)
   fmt.Println(this_arr)
}

package main

import "fmt"
//全局
var my_arr [4][6]int
var my_arr_1 [2][3]int = [...][3]int{{1, 2, 3}, {4, 5, 6}}
func main() {
   //方法内：
   this_arr := [2][3]int{{1, 2, 3}, {8, 8, 8}}
   // 第 2 纬度不能用 "..."。
   this_arr2 := [...][2]int{{1, 1}, {2, 2}, {3, 3}}
   fmt.Println(my_arr)
   fmt.Println(my_arr_1)
   fmt.Println(this_arr)
   fmt.Println(this_arr2)
}

Go中有指针的概念，Java中没有指针的概念。
指针简单的说就是存储一个【变量地址】的【变量】。

Go中使用指针的方法
//*+变量类型 = 对应变量类型的指针类型，&+变量名 = 获取变量引用地址    
var  指针变量名 *指针变量类型 = &变量名  
例如：
var my_point *int = &num
//通过&+指针变量 = 修改原来的变量真实值
&指针变量名 = 修改的变量值
例如：
&my_point = 100;

package main

import "fmt"

func main() {
 // 声明实际变量
 var name string="xiao_ming"
 // 声明指针变量
 var name_point *string
 // 指针变量的存储地址
 name_point = &name

 //直接访问变量地址
 fmt.Println("name 变量的地址是:", &name  )

 // 指针变量的存储地址
 fmt.Println("name_point变量储存的指针地址:", name_point )

 // 使用指针访问值
 fmt.Println("*name_point 变量的值:", *name_point )
}

name 变量的地址是: 0x10ae40f0
name_point变量储存的指针地址: 0x10ae40f0
*name_point 变量的值: xiao_ming

 List list = new ArrayList(); 

package main

import "fmt"

func main() {
   var num *int
   //此处num是nil
   fmt.Println(num)
   //此处会报空指针异常，因为num为nil,没有申请内存空间，所以不能为nil赋值
   *num = 1
   fmt.Println(*num)
}

package main

import "fmt"

func main() {
   //在内存中申请一块地址，并把内存地址存入num
   var num = new(int)
   //此处num的值是申请出来的内存空间地址值，一个十六进制的数字
   fmt.Println(num)
   //正常
   *num = 1
   fmt.Println(*num)
}

package main

import "fmt"

func main() {

   //make只能为map,channel,slice申请分配内存，只有这三种，没有第四种
   //所有通过make创建的这三种类型都是引用类型，传递参数时虽然是引用值传递，
   //但是对方法内引用变量参数的修改可以影响到外部的引用变量
   //1.通过make创建map对象  如下代码类似于Java中 Map<String,Integer> myMap = new HashMap<>();
   //在这里make就是申请分配map的内存，和java中创建map的new一样
   myMap := make(map[string]int)
   myMap["xiao_ming"] = 20

   //2.通过make创建channel,make函数内可以有一个参数，也可以有两个参数，有两个参数时第二个参数
   //为通道的缓存队列的长度
   //2.1) 只有一个参数，通道的缓存队列长度此时为0，也就是无缓存。
   //创建一个传输int类型数据的通道
   myChan := make(chan int)
   fmt.Println(myChan)
   //2.2) 有两个参数，第二个参数2代表此时代表缓存队列的长度为2
   //创建一个传输int类型数据的通道,缓存为2
   mychan2 := make(chan int,2)
   fmt.Println(mychan2)
   //此处暂时不做通道缓存队列数多少有何区别的讲解

   //3.通过make创建slice切片
   //有两种方式，一种是两个参数，一种是三个参数
   //我们只有在创建一个空的切片时才会使用make
   //如果通过一个已有的数组创建切片往往是下面的形式
   //创建一个底层数组
   myArr := []int{1,2,3,4,5}
   //如果通过一个数组创建切片，往往是用 原始数组变量名[切片起始位置:切片结束位置] 创建一个切片
   mySlice1 := myArr[2:4]
   fmt.Println(mySlice1)
   //我们如果是想创建一个空的slice,则用make创建切片
   //如下形式 make(int[],num1,num2)
   //num1 = 切片的长度(默认分配内存空间的元素个数)
   //num2 = 切片的容量(解释：底层数组的长度/切片的容量，超过底层数组长度append新元素时会创建一个新的底层数组，
   //不超过则会使用原来的底层数组)

   //代表底层数组的长度是4,默认给底层数组的前两个元素分配内存空间
   //切片指向前两个元素的地址，如果append新元素，在元素数小于4时都会
   //在原来的底层数组的最后一个元素新分配空间和赋值，
   //append超过4个元素时，因为原数组大小不可变，也也存储不下了，
   //所以会新创建一个新的底层数组，切片指向新的底层数组
   mySliceEmpty := make([]int,2,4)
   fmt.Println(mySliceEmpty)

   //两个参数，代表切片的长度和切片的容量(底层数组长度)均为第二个参数那个值
   mySliceEmpty2 := make([]int,5)
   fmt.Println(mySliceEmpty2)
}

Go中有的数据结构：数组，切片，map，双向链表，环形链表，堆
Go自己的类库中没有set,没有集合(List)，但是第三方库有实现。

Java中有：Map,Set,List,Queue,Stack,数组
Java中没有切片的概念。

Go中的数组打印格式是[1,2,3,4,5] 
Go中的切片打印格式是[[1,2,3]]
Go中切片的概念：切片是数组的一个子集，就是数组截取某一段。
Go的map和Java的map大致相同

Go中返回值可以有多个，不像Java中多个值得封装到实体或map返回
//注：【】内的返回值可不写，无返回值直接把返回值部分全部去掉即可。
func 函数名(变量1 变量类型，变量2 变量2类型...)【(返回值1 类型1，返回值2 类型2...)】  {        
//注意：这个方法的右中括号必须和func写在同一行才行，否则报错，不能按c语言中的换行写

package main

import "fmt"

func main() {
   //定义局部变量
   var a int = 100
   var b int = 200
   var result int

   //调用函数并返回最大值
   result = max(a, b)

   fmt.Println( "最大值是 :", result )
}

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
   /* 定义局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result
}

package main

import "fmt"

func main() {
   a, b := swap("xiao_ming", "xiao_hong")
   fmt.Println(a, b)
}

func swap(x, y string) (string, string) {
   //返回多个值
   return y, x
}

package main

import "fmt"

func main() {
 manyArgs(1,2,"2","3","4")
 manyArgs(1,2,"5","5","5")
 dataStr := []string{"11","11","11"}
 //传数组也可以，加三个点
 manyArgs(1,2,dataStr...)
}

//可变参数必须放在最后面
func manyArgs(a int,b int ,str ...string ){
 for i,s := range str {
  fmt.Println(i,s)
 }
}

package main

import "fmt"

func main() {
   testMyFunc();
}


func testDefer1() {
   fmt.Println("print defer1")
}
func testDefer2() {
   fmt.Println("print defer2")
}

func testMyFunc() {
   //defer会在方法返回前执行，有点像java中的finally
   //defer写在任意位置均可，多个defer的话按照逆序依次执行
   defer testDefer2()
   defer testDefer1()
   fmt.Println("print my func")
}

package main

import "fmt"

func main() {
   //方式一丢弃：丢弃num1和str
   _,num2,_:= testFun(1,2,"3");
   fmt.Println(num2)
   //方式二丢弃：
   _,num3,_:= testFun(1,3,"4");
   fmt.Println(num3)
}

func testFun(num1,num2 int,str string) (n1 int,n2 int,s1 string){
   n1 = num1
   n2 = num2
   s1 = str
   return
}
func testFun2(num1,num2 int,str string) (int,int,string){
   return num1,num2,str
}

 访问修饰符   返回值类型   方法名(参数1类型  参数1，参数2类型 参数2...) {

       return 返回值;
 }

 public Integer doSomething(String name,Integer age) {
    
   return 20;
 }