Go语言学习笔记1/2

书籍：《Go语言编程》

Chap 1 初识Go语言

1.Go语言主要特性：自动垃圾回收，更丰富内置类型，函数多返回值，错误处理，匿名函数和闭包，类型和接口（不支持继承和重载，仅支持组合），并发贬称，反射，语言交互性。
2.Go语言的main函数不能带有参数也不能有返回值。Go语言函数定义：
func 函数名(参数列表) (返回值列表){//函数体}
3.编译：go build hello.go；编译运行，不产生中间编译文件和执行文件：go run hello.go

Chap 2 顺序编程
1.Go语言不需要使用分号。
2.变量声明使用关键字var，格式为：var 变量名 变量类型 
3.变量初始化的三种方式：
var v1 int = 10
var v2 = 20//自动推导
v3 := 30//自动推导，完成声明和初始化，会产生变量v3，因此v3不能是已经声明的变量
虽然能自动推导，但是Go语言是强类型语言。
4.支持多重赋值，例如：i,j=j,i//交换i、j变量的值
5.函数参数中的变量是匿名变量。
6.定义常量：使用const关键字：const Pi float64 = 3.1415926
7.预定义常量：true、false和iota（可被编译器修改的常量，在每一个const关键字出现时重置为0，在下一个const出现时，没出现一次iota，其值加1）。
8.枚举类型：
const(
Sunday=iota
Monday//会自动推导，Monday等于1
Tuesday
numberOfDays//只有大写字母的对外包发布，小写字母开头的不对外发布
)
9.类型：
1)布尔类型bool：v2 := (1==2) 布尔类型不支持类型转换
2)整形：int32、int64等是固定大小的，int、uint是平台相关的，建议使用平台相关的类型。不同类型如int和int32是不能比较的，会编译错误，但是可以和字面常量（如i==1）进行比较。
3)浮点型：不能直接==进行比较，可以导入math后根据相差的大小设置范围进行相等的比较。
4)复数类型complex:var a complex
5)字符串string：var str string
通过类似数组下标访问，但是不能修改。默认为UTF-8字符，中文包括三个字节。遍历中文是可使用range函数对字符串进行Unicode字符遍历。
6)字符类型：byte代表单个utf-8字节（一个汉字三个字节），rune代表单个unicode字符（一个汉字一个字符）。
7)数组类型：数组名 [number]类型
数组类型是值类型，因此函数参数如果是数组，会发生内部的复制过程。
8)切片slice：理解为可以动态扩充的数组，函数参数传递时不会发生复制过程。
A.基于数组创造切片：mySlice=myArray[n:m]
B.使用make函数：mySlice:=make([]int,5)
9)map类型：var myMap map[Key] Value，可以使用make函数创建。
检查是否存在：value,ok := myMap["key"] 判断ok即可
10.流程控制
1)条件语句：
A.if：条件无括号，大括号要紧跟if、else行。
func calc(x int,y int) int {
        if x>y {
                return x
        } else {
                return y
        }
}
B.switch：switch后面的变量可以不写，case可以是表达式（i>5 && i<10），不用谢break，fallthrough紧跟执行。
func calc(i int) int {
        switch i {
                case 0:
                        fallthrough
                case 1:
                        fmt.Println("1")
                case 2:
                        fmt.Println("2")
                case 3:
                        fmt.Println("3")
                default:
                        fmt.Println("Default")
        }
        return 7
}
2)循环语句：仅支持for语句。for不需要用()，甚至可以不使用i(直接循环，使用break，类似于while)
func calc(x int) int {
        sum := 0
        for i:=0;i<x;i++ {
                sum+=i
        }
        return sum
}
3)跳转goto：
func calc() int {
        sum := 0
        HERE:
                fmt.Println(sum)
        sum++
        if sum<100 {
                goto HERE
        }
        return 7
}
11.函数：
1)可接受不定参数func myfunc(args ...int)然后使用range遍历(语法糖结构，调用时更方便，不必使用new int[]{1,2,3}样式传入参数)
2)不定参数支持切片操作
3)支持多返回值，使用_跳过不想使用的返回值
package main 
import (
"errors"
"fmt"
)
func Add(a,b int) (ret int, err error) {
        if a<0 || b<0 {
                err = errors.New("Should be non-negative numbers!")
                return
        }
        return a+b,nil
}
func main(){
        fmt.Println(Add(1,3))
}
12.匿名函数和闭包:
1)匿名函数可以直接赋值给某个变量
f:=func(x,y int) int {
return x+y
}
2)闭包：理解为匿名函数+系统环境（代码中的变量等内容不再代码中定义）
f:=func()(func()){
var i int = 10
return func(){
fmt.Printf("i,j:%d,%d\n",i,j)
}
}()
f()
j*=2
f()
注意：定义函数func，返回类型为func()，最后需要加()，这样i外部不能访问，之后定义的j在f的多次调用后可以不同。
13.defer（延迟函数）定义后将以先进后出的方法进行调用。panic()函数调用后：正常的函数执行流程将立即终止，但函数中之前使用defer关键字延迟执行的语句将正常展开执行，之后该函数将返回到调用函数，并导致

逐层向上执行panic流程，直至所属的goroutine中所有正在执行的函数被终止。recover()函数用于终止错误处理流程。

chap03 面向对象编程
1.定义类型使用type关键字，例如：
type Integer int
为Integer添加方法，如下：
func (a Integer) Less(b Integer) bool{
return a<b
}
如果要修改类型的值，需要使用指针，如func (a *Integer)...
2.Go语言中大多数为值引用（包括数组），引用的修改不改变被引用的值。
3.定义类型使用struct关键字，实例如下：
package main
import "fmt"
type Rect struct {
        x, y float64
}
//定义方法
func (r Rect) Area() float64 {
        return  r.x * r.y
}


func main(){
        r := &Rect{10,20} //初始化1
        fmt.Print(r.Area())
        fmt.Print("\n")
        s := new (Rect) //初始化2
        fmt.Print(s.Area())
        fmt.Print("\n")
        t := &Rect{x:30,y:40} //初始化3
        fmt.Print(t.Area())
}
4.Go通过组合的方式提供继承特性，称之为匿名组合。可以直接调用组合的方法。
package main
import "fmt"


type Base struct{
        Name string 
}
func (b *Base) SayHi() {
        fmt.Print("Hi, Base!\n")
}


type Child struct{
        Base
}


type Child1 struct{
        *Base
}
func (c *Child1) SayHi1(){
        c.Base.SayHi()
}
func (c *Child1) SayHi2(){
        c.SayHi()
}


func main(){
        b := &Base{}
        b.SayHi()
        c := &Child{*b}
        c.SayHi()
        d := &Child1{b}
        d.SayHi()
        d.Base.SayHi()
        d.SayHi1()
        d.SayHi2()
}
5.可见性方面，大写表示对外可见，小写只是包内可见。
6.Go语言中，只要一个类实现了接口所有的方法，就说明该类实现了接口。接口定义如下：
package main
import "fmt"


type  File  struct{
        Name string
}
func (f *File) Read() {
        fmt.Print("Read")
}


type IFile interface {
        Read()
}


func main(){
        var ifc IFile = new(File)
        ifc.Read()
}
7.接口赋值类似类型转换，可以从接口多的转换为接口少的。
8.接口查询：
if file,ok:file1.(IStream);ok{
...
}
检查file1是否实现IStream接口，如果实现，执行{}中语句。
9.类型查询：
var v1 interface{} = ...
switch v:=v1.(type){
case int:
case string:
...
}
10.接口可以组合，跟类的组合一致。
11.interface{}可以用于定义Any类型。