一.流程控制

　1.选择结构

　　if-else：

package main

import (

    "io/ioutil"

    "fmt"

)

func main(){

    const filename="abc.txt"

    //读文件

    content,err :=ioutil.ReadFile(filename)

    if err !=nil{

        fmt.Println(err)

    }else{

        fmt.Printf("%s\n",content)

    }

    //if也支持如下语法

    if content,err :=ioutil.ReadFile(filename);err !=nil{

        fmt.Println(err)

    }else{

        fmt.Printf("%s\n",content)

    }

}

　　switch：

package main

import "fmt"

//传入成绩，返回评分等级

func grade(score int) string {

    //定义字符串

    g := ""

    //go为switch每一句都加了break

    switch {

    case score < 0 || score > 100:

        g = "输入错误"

    case score < 60:

        g = "不及格"

    case score < 80:

        g = "良"

    case score < 90:

        g = "优"

    case score <= 100:

        g = "GOOD"

    }

    //default: "hahah"

    return g

}

func main(){

    fmt.Println(

        grade(0),

        grade(61),

        grade(75),

        grade(86),

        grade(86),

        grade(101),

    )

}

　　2.循环结构

　　　　for：

package main

import (

    "fmt"

    "time"

)

//死循环

func for1(){

    for {

        fmt.Println("波多野结衣的奶子大大的")

        //睡一秒

        time.Sleep(1*time.Second)

    }

}

//有次数的循环

func for2(){

    for i :=1;i<10;i++ {

        fmt.Println("波多野结衣可以让我幸福死")

    }

}

//有次数的循环加控制

func for3(){

    for i :=1;i<10;i++{

        if i%5==0{

            fmt.Println("我爱苍老师")

        }else if i%2==1{

            fmt.Println("我爱波多老师")

        }else{

            fmt.Println("我爱大桥未久")

        }

        time.Sleep(1*time.Second)

    }

}

func main(){

    //for1()

    //for2()

    for3()

}

　　　　range：

package main

import "fmt"

func main(){

    s :="abc"

    for i :=range s{

        fmt.Printf("下标%d，值=%c\n",i,s[i])

    }

    //直接都收到

    for i,c :=range s{

        fmt.Printf("下标%d，值=%c\n",i,c)

    }

    for _,c :=range s{

        fmt.Printf("值=%c\n",c)

    }

}

　　3.跳转语句

　　　　continue和break

package main

import "fmt"

func main(){

    for  i :=0;i<5;i++{

        if i==2{

            //break是直接打断，continue，跳过

            //break

            //continue

        }

        fmt.Println(i)

    }

}

　　goto：

package main

import "fmt"

func main(){

    for i :=1;i<5;i++{

        fmt.Println(i)

        //goto必须跳转到方法内

        goto LABEL2

    }

    fmt.Println("程序结束")

LABEL2:

    fmt.Println("程序over")

}

二.函数

　　1.自定义函数

   函数声明格式：

   方法名首字母大写是public，方法名首字母小写是private

　　func 函数名( [参数列表] ) [返回值列表] {

   　　函数体

　　}

　　　　分类：

package main

import "fmt"

//无参数无返回值

func Test1(){

    fmt.Println("公共的")

}

//有参数无返回值

func Test2(v1 int,v2 int){

    fmt.Println(v1,v2)

}

//有不定参数无返回值

func Test3(args ...int){

    //这边的前面是索引，后面的是值

    for _,n :=range args{

        fmt.Println(n)

    }

}

//无参数有返回值

func Test4()(a int,str string){

    a=666

    str="喜欢骑苍老师"

    return

}

func Test5()(int,string){

    return 250,"喜欢被苍老师骑"

}

//有参数有返回值（求两个数的最大值和最小值）

func Test6(num1 int,num2 int)(min int,max int){

    if num1>num2{

        min=num2

        max=num1

    }else{

        min=num1

        max=num2

    }

    return

}

func main(){

    Test1()

    Test2(1,2)

    Test3()

    Test3(1,2,3,4)

    fmt.Println(Test4())

    fmt.Println(Test5())

    fmt.Println(Test6(2,1))

}

　　例题：求1.。。100的和

package main

import "fmt"

// 循环实现1到100累加

func Test01() int {

   sum := 0

   for i := 1; i <= 100; i++ {

      sum += i

   }

   return sum

}

//递归实现

//传100

func Test02(num int) int {

   if num == 1 {

      return 1

   }

   return num + Test02(num-1)

}

func main() {

   fmt.Println(Test01())

   fmt.Println(Test02(100))

}

　　2.defer关键字，延迟操作

　　

    defer⽤于延迟一个函数或者方法的执行

    defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁

    通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放

    释放资源的defer应该直接跟在请求资源的语句后，以免忘记释放资源
package main

import "fmt"

func test(x int) {

    fmt.Println(100 / x)

}

func main() {

    //defer是延迟操作

    defer fmt.Println("aaaa")

    defer fmt.Println("bbbb")

    //报错并不影响程序运行

    defer test(0)

    defer fmt.Println("cccc")

}

　　三.复合类型

　　1.指针

    go语言中指针是很容易学习的，比C中容易的多，它可以更简单地执行一些任务

    与变量类似，使用前需要声明

    声明指针的格式：

var 指针变量名 *指针类型

　　

　　简单使用：

package main

import "fmt"

func main(){

    //声明变量

    var a int=10

    //声明指针

    var p *int

    //指针变量储存

    p=&a

    fmt.Printf("a变量的地址是%x\n",&a)

    //指针变量的存储地址

    fmt.Printf("p变量的指针地址%x\n",p)

    //使用指针访问值

    fmt.Printf("*p变量的值是：%d\n",*p)

}

　　使用指针改变所指向的内存的值

package main

import "fmt"

func main(){

    //定义变量

    var num int=10

    fmt.Println(&num)

    //定义指针

    var prt *int

    //g给指针赋值（指针指向哪个内存地址）

    prt=&num

    *prt=20

    fmt.Println(num) //20

}

　　

　　值传递和引用传递

  go空指针，go空是用nil

　　

答案　　3,4

　　再看几个例子

package main

import "fmt"

//变量交换

//go方法是值传递

func swap(a,b int){

	a,b =b,a

}

func main(){

	a,b :=3,4

	swap(a,b)

	fmt.Println(a,b)

}

　　答案是3,4

package main

import "fmt"

//go方法参数是值传递

func swap(a,b *int){

	*a,*b =*b,*a

}

func main()  {

	a,b :=3,4

	//指针是存地址的

	swap(&a,&b)

	fmt.Println(a,b)

}

　　答案是：4,3

　　另一种方法

package main

import "fmt"

//go方法参数是值传递

func swap(a,b int)(int,int){

	return b,a

}

func main()  {

	a,b :=3,4

	//指针是存地址的

	a,b=swap(a,b)

	fmt.Println(a,b)

}

　　

　　2.new和make

    new()用来分配内存，但与其他语言中的同名函数不同，它不会初始化内存，只会将内存置零

    make(T)会返回一个指针，该指针指向新分配的，类型为T的零值，适用于创建结构体

    make()的目的不同于new()，它只能创建slice、map、channel，并返回类型为T（非指针）的已初始化（非零值）的值

　　看一个例子

package main

import (

    "fmt"

)

func main(){

    //未初始化

    p :=new([] int)

    fmt.Println(p)

    //已经初始化

    v:=make([] int,10,50)

    fmt.Println(v)

    //*p[0]=10  会报错，下标越界，未初始化为分配

    v[0]=10

    fmt.Print(v)

}

　　

　　3.数组

    声明数组：

var 数组名[数组长度] 数组类型

    声明和初始化数组

    数组遍历

    数组是值类型还是引用类型？

　　看一个例子

package main

import "fmt"

func main(){

    //1.定义数组

    //数组必须制定长度和类型

    var arr1[5] int

    //:=创建，必须赋值

    arr2:=[3] int{1,2,3}

    //3省累大小

    arr3 :=[...]int{2,3,4,5,}

    fmt.Println(arr1,arr2,arr3)

    var grid[ 4][5]int

    fmt.Println(grid)

    //数组遍历

    //1.直接遍历

    for i:=0;i<len(arr3);i++{

        fmt.Println(arr3[i])

    }

    //2.range

    for i,v:=range arr3{

        fmt.Println(i,v)

    }

}

　　数组是值传递还是引用传递

package main

import "fmt"

func main(){

    //1.定义数组

    //数组必须制定长度和类型

    var arr1[5] int

    //:=创建，必须赋值

    arr2:=[3] int{1,2,3}

    //3省累大小

    arr3 :=[...]int{2,3,4,5,}

    fmt.Println(arr1,arr2,arr3)

    var grid[ 4][5]int

    fmt.Println(grid)

    //数组遍历

    //1.直接遍历

    for i:=0;i<len(arr3);i++{

        fmt.Println(arr3[i])

    }

    //2.range

    for i,v:=range arr3{

        fmt.Println(i,v)

    }

}

　　

　　数组和列表的区别，有类型，有大小，不可变

　　使用指针

package main

import "fmt"

//方法传入数组，修改元素

func printArr(arr *[5] int){

    arr[0]=100

    for i,v:=range arr{

        fmt.Println(i,v)

    }

}

func main(){

    //定义数组

    var arr1 [5]int

    arr2 := [3]int{1, 2, 3}

    arr3 := [...]int{2, 4, 6, 8, 10}

    fmt.Println(arr1, arr2, arr3)

    printArr(&arr1)

    //不同长度，不能传参

    //printArr(arr2)

    printArr(&arr3)

    fmt.Println()

    fmt.Println(arr1, arr3)

}

　　

　　说明是值传递

　　4.slice

    数组的长度在定义之后无法再次修改，go语言提供了数组切片（slice）来弥补数组的不足

    创建切片的各种方式

    切片的操作

    内建函数append()

    内建函数copy()

　　　切片的创建

package main

import "fmt"

func main(){

    //声明切片和数组不一样的是不用指定大小

    var s1 []int

    fmt.Println(s1)

    //:声明,必须{}，：声明的必须赋值

    s2:=[] int{}

    fmt.Println(s2)

    //make

    //诺写一个0.则代表大小和容量都是0

    //var s3 [] int=make([] int,0)

    //d声明的时候大小为10，存11个也没问题

    var s3 [] int=make([] int,10,10)

    fmt.Println(s3)

    s4 := []int{1, 2, 3}

    fmt.Println(s4)

}

　　切片的操作（取值）

package main

import "fmt"

func main(){

    //其切片取值

    arr :=[...]int{1,2,3,4,5,6,7}

    fmt.Println("arr[2:6]=",arr[2:6])

    fmt.Println("arr[:6]=",arr[:6])

    fmt.Println("arr[2:]=",arr[2:])

    fmt.Println("arr[:]=",arr[:])

}

　　　　

　　　

　　　　　  内建函数append()：向切片尾部添加数据

package main

import "fmt"

func main(){

    var s1 [] int

    s1=append(s1,1)

    fmt.Println(s1)

    s1=append(s1,2,3)

    fmt.Println(s1)

    s1=append(s1,4,5,6)

    fmt.Println(s1)

    //创建指定大小的切片

    s2:=make([] int,5)

    s2=append(s2,6)

    fmt.Println(s2)

    //创建并初始化切片

    s3:=[]int{1,2,3}

    s3=append(s3,4)

    fmt.Println(s3)

}

//从这个例子也能看出数组和切片的区别

　　

　　　　 go语言切片实际上是view操作

package main

import "fmt"

func main() {

    //1.go语言切片是对原数组的映射，并没有创建一个真正的切片

    // 定义数组

    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}

    //取切片

    s1 := arr[2:]

    //修改值

    s1[0] = 100

    fmt.Println(s1)

    fmt.Println(arr)

    fmt.Println()

    // go语言切片没有取到的位置，可以向后延申，不可向前延申

    s3 := arr[2:6]

    fmt.Println(s3)

    s4 := s3[3:5]

    fmt.Println(s4)

    //容量和大小

    fmt.Printf("s3=%v,len(s3)=%d,cap(s3)=%d\n", s3, len(s3), cap(s3))

}

　　

　　append操作切片

package main

import "fmt"

func main() {

   //1.go语言切片是对原数组的映射，并没有创建一个真正的切片

   // 定义数组

   arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}

   //取切片

   s1 := arr[2:6]

   fmt.Println(s1)

   s2 := s1[3:5]

   fmt.Println(s2)

   s3 := append(s2,10)

   fmt.Println(s3)

   fmt.Println(arr)

   s4 := append(s3,11)

   fmt.Println(s4)

   fmt.Println(arr)

   s5 := append(s4,12)

   fmt.Println(s5)

   fmt.Println(arr)

}

　　

　　5.map

    Map 是go内置的数据结构，是一种无序的键值对的集合，可以通过key快速找到value的值

    定义Map：

var 变量名 map[key的数据类型] value的数据类型

    创建map

    初始化map

    键值操作

    遍历

    删除

    练习，创建5个方法，创建map，遍历map，删除键值对，修改map，map查询

　　6.结构体

    go语言没有class，只是个结构体struct

    结构体定义：

type 结构体名 struct{}

    结构体初始化

　　7.结构体参数

    结构体可以作为函数参数传递

四.面向对象

　　1.简介

go语言对于面向对象的设计非常简洁而优雅

没有封装、继承、多态这些概念，但同样通过别的方式实现这些特性

　　2.匿名字段

    go支持只提供类型而不写字段名的方式，也就是匿名字段，也称为嵌入字段

    同名字段的情况

    所有的内置类型和自定义类型都是可以作为匿名字段去使用

    指针类型匿名字段

　　3.方法

    在面向对象编程中，一个对象其实也就是一个简单的值或者一个变量，在这个对象中会包含一些函数

    这种带有接收者的函数，我们称为方法，本质上，一个方法则是一个和特殊类型关联的函数

    方法的语法如下

func (接收参数名 接收类型) 方法名(参数列表)(返回值)

    可以给任意自定义类型（包括内置类型，但不包括指针类型）添加相应的方法

    接收类型可以是指针或非指针类型

    为类型添加方法

    值语义和引用语义

    方法的继承

    方法的重写

    方法值和方法表达式

    练习：创建属性的getter和setter方法并进行调用

　　4.  包和封装

    方法首字母大写：public

    方法首字母小写：private

    为结构体定义的方法必须放在同一个包内，可以是不同的文件

　　5.接口

    go语言中，接口（interface）是一个自定义类型，描述了一系列方法的集合

    接口不能被实例化

    接口定义语法如下

type 接口名 interface{}

    PS：接口命名习惯以er结尾

    接口定义与实现

    接口继承

    空接口

    类型查询

    comma-ok断言

    switch测试

　　6.面向对象练习

    定义接口IPerson，定义吃喝睡三个抽象方法

    定义结构体Person，实现上述方法

    定义一个Person的实现类Worker即劳动者，拥有劳动方法Work()(output string)其中output是其工作产出，和休息方法Rest()

    继承IWorker实现三个不同职业的子类：程序员Coder、老师Teacher、农民Farmer

    创建一个IWorker的数组，将3个实例添加进去

    main中测试工作日和周末，输出如下打印

五.异常处理　

　　1.抛异常和处理异常

系统抛

自己抛

　　2.返回异常

六.处理字符串

　

最新文章

  1. C# WebBrowser 网页缩放的方法
  2. java中父类与子类， 不同的两个类中的因为构造函数由于递归调用导致栈溢出问题
  3. 正则表达式之IP地址检验
  4. Controller 接口控制器详解
  5. SQL——存储过程实例 调用带参数的过程（成绩输出）
  6. Performance Analysis Methodology
  7. A Neural Probabilistic Language Model
  8. Android 防止按钮连续点击的方法（Button,ImageButton等）
  9. 【转】selenium及webdriver的原理
  10. 命令行创建maven模块工程
  11. MateSublg
  12. 13_FCITX输入法安装及问题排查解决
  13. mycat实例（2）
  14. 透过 Delphi 使用二进位金钥做 AES 加密.
  15. EF5.0默认不支持DB First了？
  16. [NOI2015]软件包管理器
  17. Javascript我学之三函数的参数
  18. Shell 同步时间脚本
  19. Android AndFix修复方式的限制
  20. delphi 控件编辑器

热门文章

  1. B 小雨的三角形
  2. verilog乘法器的设计
  3. python二叉树及叶节点获取 (面试题)
  4. Ionic3学习笔记（七）Storage
  5. linux查看端口号占用命令-top
  6. kNN算法 Demo
  7. React Native 学习笔记--进阶（二）--动画
  8. hexo创建新文章的正确方法
  9. Introduction Of Gradient Descent
  10. USB描述符（转）