1.当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

注意要分清是否跨包

package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

3.全局变量是允许声明但不使用,局部变量不能重新声明而且声明了必须要使用
4.空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

5.常量可以用len(), cap(), unsafe.Sizeof()常量计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
    println(a, b, c)
}

6.iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

7.指针变量与变量地址

package main
import "fmt"
func main() {
    var a int = 4
    var b int32
    var c float32
    var ptr *int
    /* 运算符实例 */
    fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
    fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
    fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

    /*  & 和 * 运算符实例 */
    ptr = &a    /* 'ptr' 包含了 'a' 变量的地址 */
    fmt.Printf("a 的值为  %d\n", a);
    fmt.Printf("*ptr 为 %d\n", *ptr);
    a=5
    fmt.Printf("ptr 为 %d\n", ptr);//825741050416
    fmt.Printf("*ptr 为 %d\n", *ptr);//5
    *ptr=7
    fmt.Println(*ptr,a)//7 7
}

8 . if不强制加括号

package main
import "fmt"
func main() {
    var a int = 100;
    if a < 20 {
        fmt.Printf("a 小于 20\n" );
    } else if a>100{
        fmt.Printf("a > 100\n" );
    }else{
        fmt.Printf("其他" );
    }
}

9.for 循环

package main
import "fmt"
func main() {
    var b int = 15
    var a int
    numbers := [6]int{1, 2, 3, 5}
    /* for 循环 */
    for a := 0; a < 10; a++ {
        fmt.Printf("a 的值为: %d\n", a)
    }
    for a < b {
        a++
        fmt.Printf("a 的值为: %d\n", a)
    }
    //range可以对 slice、map、数组、字符串等进行迭代循环
    for i,x:= range numbers {
        fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
    }
    for{
        fmt.Printf("无限循环")
    }
}

goto不推荐用

package main
import "fmt"
func main() {
   /* 定义局部变量 */
   var a int = 10
   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++     
   }  
}

10 . 函数

package main
import "fmt"
func swap(x int, y string) (string, int) {
    return y, x
}
func swap1(x , y string) (string, string) {
    return y, x
}
func swap2(y string) string {
    return y
}
func main() {
    a, b := swap(1, "Kumar")
    fmt.Println(a, b)
}

11.闭包

package main
import "fmt"
func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
     return i  
   }
}
func main(){
   /* nextNumber 为一个函数，函数 i 为 0 */
   nextNumber := getSequence()  

   /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   
   /* 创建新的函数 nextNumber1，并查看结果 */
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}

12.函数方法，是否可以理解成java对象内部方法

package main
import (
   "fmt"  
)
/* 定义函数 */
type Circle struct {
  radius float64
}
func main() {
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("Area of Circle(c1) = ", c1.getArea())
}
//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

13.全局变量，同一个包内不能重名，不然编译报错
pointer类型变量默认值为nil
14.数组

package main

import "fmt"

func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int

   /* 为数组 n 初始化元素 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }

   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

15.再次强调指针

package main

import "fmt"

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

   fmt.Printf("交换前 a 的值 : %d\n", a )
   fmt.Printf("交换前 b 的值 : %d\n", b )

   /* 调用函数用于交换值
   * &a 指向 a 变量的地址
   * &b 指向 b 变量的地址
   */
   swap(&a, &b);

   fmt.Printf("交换后 a 的值 : %d\n", a )
   fmt.Printf("交换后 b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址的值 */
   *x = *y      /* 将 y 赋值给 x */
   *y = temp    /* 将 temp 赋值给 y */
}

*x = *y只是值交换，为啥？因为它们指向的地址是a/b,不同的地址

“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递
不同于java如果想达到引用传递的效果，go要加上指针符号*才可以
16.结构体

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* Declare Book1 of type Book */
   var Book2 Books        /* Declare Book2 of type Book */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   printBook(&Book1)

   /* 打印 Book2 信息 */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

17 切片
像java的list

package main

import "fmt"
func main() {
    var numbers = make([]int,3,5)
    printSlice(numbers)
    s :=[] int {1,2,3 }
    printSlice(s)
    var numbers1 []int
    printSlice(numbers1)
    if(numbers1== nil){
        fmt.Println("切片是空的")
    }
    /* 打印子切片从索引1(包含) 到索引3(不包含)*/
    fmt.Println("s[1:3] ==", s[1:3])
    /* 默认下限为 0*/
    fmt.Println("s[:3] ==", s[:3])
    /* 默认上限为 len(s)*/
    fmt.Println("s[2:] ==", s[2:])
    numbers=append(numbers, 0,1,2,3,4,5,6)
    fmt.Println(numbers,cap(numbers))
    /* 创建切片 numbersc 是之前切片的两倍容量*/
    numbersc := make([]int, len(numbers), (cap(numbers))*2)
    /* 拷贝 numbers 的内容到 numbersc */
    copy(numbersc,numbers)
    fmt.Println(numbersc)
}

func printSlice(x []int){
    fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)//len=3 cap=5 slice=[0 0 0]
}

18 map

package main

import "fmt"
func main() {
    var countryCapitalMap map[string]int
    /* 创建集合 */
    countryCapitalMap = make(map[string]int)

    /* map 插入 key-value 对，各个国家对应的首都 */
    countryCapitalMap["France"] = 1
    countryCapitalMap["Italy"] = 2
    countryCapitalMap["Japan"] = 3
    countryCapitalMap["India"] = 4
    delete(countryCapitalMap,"India");
    /* 使用 key 输出 map 值 */
    for country := range countryCapitalMap {
        fmt.Println("Capital of",country,"is",countryCapitalMap[country])
    }

    /* 查看元素在集合中是否存在 */
    captial, ok := countryCapitalMap["United States"]
    /* 如果 ok 是 true, 则存在，否则不存在 */
    if(ok){
        fmt.Println("Capital of United States is", captial)
    }else {
        fmt.Println("Capital of United States is not present")
    }
}

19 接口

package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}

20 异常

package main
import (
    "fmt"
    "errors"
)
func main() {
    var err error = errors.New("this is a new error")
    //由于已经实现了error接口的方法 因此可以直接调用对应的方法
    fmt.Println(err.Error())

}

21 包内其他文件的变量和方法随便用，跨包则要通过“packageName.”方式引用了
22 工程文件下要有main包，且main包下文件不能包含重复main方法