go学习之流程控制语句

流程控制语句

介绍：在程序中，程序运行的流程控制决定程序如何执行的，是我们应该掌握的，主要有三大流程控制语句

1.顺序控制

介绍：程序从上到下逐行地执行，中间没有任何判断效果

一个案例说明，必须下面的代码，没有判断，也没有跳转。因此程序按照默认的流程执行。即顺序控制

var days int  = 97
var week int =days / 7
var day int = days % 7
fmt.Println("%d个星期零%d天",week,day)

流程图

顺序控制举例和注意事项

Golang中定义变量时采用合法额前向引用。如

func main(){
var num1 int = 0
var num2 int = num1 + 20
fmt.Println(num2)
}
错误形式：不可以先使用后声明
func main(){
var num2 int = num1 + 20 //错误，一定要注意先后顺序
var num1 int = 10
fmt,Println(num2)
}

2.分支控制

分支控制if-else介绍

让程序有选择的执行，分支控制有三种。

2.1单分支

基本语法

if 条件表达式{
   执行代码块
}
说明：当条件表达式为true时，就会执行{}的代码。
注意：{}是必须有的，就算你只写一行代码

应用案例

package main

import (
	"fmt"
)
//编写一个程序可以输入一个人的年龄，
// 如果同志的年龄大于18岁则输出你的年龄大于18岁
//要对自己的行为负责

//分析：年龄 ==》var age int
//2.从控制台接收输入

func main(){
var age int
fmt.Println("请输入你的年龄:")
fmt.Scanln(&age)
if age >=18 {
	fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")
      }
}

单分支细节说明

Go的if还有一个强大的地方就是条件判断语句里允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了

//golang支持在if中，直接定义一个变量，比如下面的
if age := 20; age > 18{
     fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")
}

2.2双分支

基本语法

if 条件表达式{
    执行代码块1
}else{
    执行代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2{}也是必须有的

func main(){
var age int
fmt.Println("请输入你的年龄:")
fmt.Scanln(&age)
if age >=18 {
	fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")
      }else{//强制编程语法。else一定在这个地方
		fmt.Println("你的年龄不大，这次放过你了")
	  }

}

双分支细节

双分支只会执行其中的一个分支。

package main

import (
	"fmt"
)
func main(){
	var x int = 1
	var y int = 1
	if(x>2){//golang中可以写小括号，但是官方不推荐就是
		if(y>2){
			fmt.Println(x+y)
		}
		fmt.Println("hello")
	}else{
		fmt.Println("x is =",x) //输出x=1
	}
}

var x int = 4
if > 2  //编译都不会通过，因为没有大括号
  fmt.Println("ok")
else
  fmt.Println("helo")
//没有大括号就是错的。编译错误没有什么输出

判断下列代码是否正确
var x int = 4
if x >2{
    fmt.Println("ok")
}//也是错的因为else要在这个括号的后面
else{
    fmt.Println("hello")
}
//编译错误，原因是else不能换行输出

单分支和双分支的四个题目

1）编写程序，声明2 个 int32型变量并赋值。判断两个数之和。如果大于等于50，打印“hello world"

var a int32 =45
	var b int32 =78
    if a+b>=50 {
		fmt.Println("这个数的和大于50")
	}

2)编写程序，声明2个float64型变量并赋值，判断第一个数大于10.0且第二个数小于20.0打印这两个数之和

 //第二题
	var c float64 =11.0
	var d float64 =17.0
	if c > 10.0 && d < 20.0 {
		fmt.Println("和=",(c+d)) //和=28
	}

3）定义两个变量int32 判断二者之和，是否能被3又被5整除，打印提示信息

//第三题
	var num1 int32 = 3
	var num2 int32 = 12
	if (num1 + num2) % 3 ==0 && (num1 + num2) % 5 == 0 {
		fmt.Println("能被三整除又可以被5整除")
	}

4）判断一个年份是否为闰年 ，闰年的条件时符合二者条件之一：（1）年份能被4整除但不能被100整除；（2）能被400整除

//第四题求润年
	fmt.Println("请输入相应的年份：")
	fmt.Scanf("%d",&year)
	if (year% 4==0 && year % 100 !=0) || year % 400 ==0{
		fmt.Printf("%d是润年",year)
	}else{
		fmt.Printf("%d不是润年",year)
	}

2.3多分支

基本语法:

if 条件表达式1{
执行代码块1
}else if 条件表达式2 {
       执行代码块2
}
...
else{
  执行代码块n
}

对上面基本语法的说明

1）多分支的判断流程如下

（1）先判断条件表达式1是否成立，如果为真，就执行代码块1

（2）如果条件表达式1为假就继续判断条件表达式2是否成立，如果条件表达式2为真就执行代码块2，

（3）以此类推

（4）如果所有条件表达式不成立，则执行else的语句块。

2）else不是必须的

3）多分支最终只能有一个执行入口

流程图（更加清晰的说清楚）：

func main(){
	//多分支类型的理解
	/*岳小鹏参加golang考试，他和父亲岳不群达成承诺
	如果
	成绩100分奖励一台bmw
	成绩为(80,90)奖励一套iphone14
	当成绩（60,80）奖励一台ipad
	其他时，什么奖励都没有
	请从键盘输入岳小鹏的期末成绩，并加以判断*/
	var score int
	fmt.Println("请输入岳小鹏的成绩：")
	fmt.Scanf("%d",&score)
	if score==100{
		fmt.Println("奖励一台BMW")
	}else if score>80&&score<=99{
        fmt.Println("奖励一台iphone14")
	}else if score>=60&&score<=80{
		fmt.Println("奖励一个ipad")
	}else{
		fmt.Println("对不起，他什么都没有好好学习")
	}
}

分支控制if-else案例介绍

var b bool = true
	if b= false{ //在这里不能赋值，只能写成==
		fmt.Println("a")
	}else if b {
		fmt.Println("b")
	}else if !b {
		fmt.Println("c")
	}else {
		fmt.Println("d")
	}

package main

import (
	"fmt"
	"math"
)
func main(){
	//分析思路
	//1.a,b,c是三个float64
	//2.使用到给出的书序公式
	//3.使用到多分支
	//4.使用到math.squr方法
	//走代码
	var a float64 =3.0
	var b float64 =1.0
	var c float64 =10.0
	

	m := b*b -4 * a * c
	//多分支判断
	if m>0 {
		x1 :=-b + math.Sqrt(m) / 2 * a
		x2 :=-b - math.Sqrt(m) / 2 * a
		fmt.Printf("x1=%v,x2=%v",x1,x2)
	}else if m == 0 {
        x1 := (-b + math.Sqrt(m)) / 2 *a
		fmt.Printf("x1=%v",x1)
	}else{
		fmt.Println("无解...")
	}

//分析思路
	//设计三个变量，需要从控制台输入
	var height int32
	var money float32
	var handsome bool
	fmt.Println("请你输入身高(厘米)")
	fmt.Scanln(&height)
	fmt.Println("请你输入财富")
	fmt.Scanln(&money)
	fmt.Println("帅吗")
	fmt.Scanln(&handsome)
	if height>180 && money>10000000.0 && handsome==true{
		fmt.Println("我一定要嫁给他")
	}else if height>180 || money>10000000.0 || handsome==true{
        fmt.Println("嫁吧，比上不足，比下有余")
	}else{
		fmt.Println("不嫁")
	}

嵌套分支

基本介绍：

在一个分支结构中又完整嵌套了另一个完整的分支结构，里面的分支结构称为内层分支外面的称为外层分支

基本语法

if条件表达式{
  if条件表达式{
  
  }else{
  
  }
}

注意：嵌套分支不宜过多，建议控制在3层内

应用案例1：

参加白米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据特别提示进入男子组或女子组，输入成绩和性别，进行判断

float64 second | string gender

var   second float64
	fmt.Println("请输入你的比赛成绩")
	fmt.Scanln(&second)
	//先判断是否进入决赛
	if second <=8{
		//进入决赛了
		var  gender string
		fmt.Println("请问您的性别是")
	    fmt.Scanln(&gender)
		if gender == "男"{
			fmt.Println("恭喜你进入男子组决赛")
		}else{
			fmt.Println("恭喜你进入女子组决赛")
		}

	}else{
		fmt.Println("对不起你被淘汰了")
	}

//案例2：出票系统
func main(){
	/*
	出票系统：根据淡旺季的月份和年龄。打印票价 【考虑学生先做】
	4~10旺季“
	  成人（18-60）:60
	  儿童（<18）:半价
	  老人(>60)：1/3

	 淡季：
	    成人：40
		其他：20 

		//分析思路
		1.month age两个变量 byte
		2.使用嵌套分支
	*/
	var month byte
	var age byte
	var price float64 =60.0
	fmt.Println("请输入您旅游的月份")
    fmt.Scanln(&month)
	fmt.Println("请输入您旅游的年龄")
    fmt.Scanln(&age)

	if month>=4 && month<=10{
		if age > 60{
			fmt.Printf("票价是%v",price / 3)
		}else if age >=18{
            fmt.Printf("票价是%v",price)
		}else{
			fmt.Printf("票价： %v",price / 2)
		}
	}else{
		if age >=18 && age <60{
           fmt.Println("票价是",40)
		}else{
			fmt.Println("票价是",20)
		}
	}

switch分支结构

1）switch语句用于基于不同条件执行不同动作，。每一个case分支都是唯一的，从上到下逐一测试，直到匹配为止

2）匹配项后面也不需要再加break

基本语法

switch 表达式{
case 表达式1,表达式2,...:
     语句块1
case 表达式3,表达式4,...:
     语句块2
...
default:
     语句块
}

switch流程图

对上图的说明和总结

1）switch的执行的流程是，先执行表达式,得到值，然后和case表达式进行比较，如果相等，就匹配到，然后执行对应的case语句块，然后退出switch的控制

2）如果switch的表达式的值没有和任何表达式的值匹配成功，执行后退出switch机制

3)golang的表达式可以有多个，并且使用逗号间隔

4）golang中的case语句块不需要写break，因为默认就会有break.当程序执行完语句块之后，就直接退出该switch控制结构

案例：

请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f a表示星期一， b表示星期二…根据用户输入显示相应的信息，要求使用switch语句完成

func main(){
	/*
	请编写一个程序，该程序可以接收一个字符，
	比如：a,b,c,d,e,f a表示星期一，
	 b表示星期二...根据用户输入显示相应的信息，
	 要求使用switch语句完成
	 分析：
	 1，定义一个变量接受字符
	 2.使用switch完成
	*/
	var key byte
	fmt.Println("请输入一个字符  a b c d e f g")
	fmt.Scanf("%c",&key)

	switch key {
	case 'a':
		fmt.Println("周一")
	case 'b':
		fmt.Println("周二")
	case 'c':
		fmt.Println("周三")
	case 'd':
		fmt.Println("周四")
	case 'e':
		fmt.Println("周五")
	case 'f':
		fmt.Println("周六")
	case 'g':
		fmt.Println("周日")	
    default:
        fmt.Println("输入有误")						

	}

​ 关于switch的细节讨论

1）case后是一个表达式（即：常量值、变量、一个有返回值的函数等都可以）

//写一个非常简单的函数
func test(b byte) byte {
	return b+1

}
func main(){	
	var key byte
	fmt.Println("请输入一个字符  a b c d e f g")
	fmt.Scanf("%c",&key)

	switch test(key) { //调用、test函数

2）case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致

var n1 int32 = 20
	var n2 int32 = 20 //改为int64是错误的

	switch n1{//n2的类型需要与n1保持一致
	case n2 :
		fmt.Println("ok") //输出了ok
	default:
		fmt.Println("输入有误")			
	}

3）case后面可以带多个表达式，使用逗号间隔。比如case表达式1，表达式2

var n1 int32 = 5
	var n2 int32 = 20 //改为int64是错误的

	switch n1{//n2的类型需要与n1保持一致
	case n2,10,5 : //case后面可以有多个表达值。匹配其中的一个就可以
		fmt.Println("ok") //输出了ok
	default:
		fmt.Println("输入有误")			
	}

4)case后面的表达式如果是常量值（字面量）则要求不能重复

var n1 int32 = 20
	var n2 int32 = 20 //改为int64是错误的
    var n3 int32 =5
	switch n1{//n2的类型需要与n1保持一致
	case n2,10,5 : //case后面可以有多个表达值。匹配其中的一个就可以
		fmt.Println("ok") //输出了ok
    case 5://错误上面已经有一个匹配值了，我们不可以重复case
         fmt.Print("5")
    case n3: //这种情况是可以正常进行编译操作的的可以说是骗过了编译器
         fmt.Println("n3")
	default:
		fmt.Println("输入有误")			
	}

5）case后面不需要带break程序匹配到一个case后就会执行对应的代码块，然后退出switch,如果一个斗匹配不到则执行default

6）default语句不是必须的

我们不写default也可以

7）switch后也可以不带表达式，类似于if-else分支来使用

//switch后可以不带表达式，类似于if -else 分支来使用
	var age int = 10
	switch {
	case age ==10 :
		fmt.Println("age ==10")
    case age ==20 :
		fmt.Println("age ==20")
    case age ==30 :
		fmt.Println("age ==30")
	default :
	    fmt.Println("没有匹配到")				
	}
//case中也可以就age的范围进行判断
	var score int = 90
	switch {
	case score > 90 :
		fmt.Println("成绩优秀")
	case score >=70 && score <=90 :
		fmt.Println("成绩优良")
	case score >=60 && score <70 :
		fmt.Println("成绩及格")
	default :
	fmt.Println("不及格")		
	}

8）switch后也可以直接声明/定义一个变量，分号结束，不推荐

//switch后也可以直接声明/定义一个变量,分号结束，并不推荐
	switch grade :=90; {
	case grade > 90 :
		fmt.Println("成绩优秀")
	case grade >=70 && grade <=90 :
		fmt.Println("成绩优良")
	case grade >=60 && grade <70 :
		fmt.Println("成绩及格")
	default :
	fmt.Println("不及格")		
	}

9）switch穿透-fallthough，如果在case语句块后增加fallthrough,则会继续执行下一个case也叫switch穿透

	//switch的穿透 fallthrought
	var num int = 10
	switch num{
	case 10 :
		fmt.Println("ok1")
		fallthrough  //默认只能穿透一层
    case 30 :
		fmt.Println("ok2")
    case 20 :
		fmt.Println("ok3")		
	default :
		fmt.Println("没有匹配到")				
	}

10)Type Switch ：switch语句还可以被用于 typ-switch来判断某个interface变量中实际指向的变量类型 xtype()类似于多态操作

	var x interface{}
	var y = 10.0
	x = y 
	switch i:= x.(type){
	case nil:
		fmt.Printf("x的类型是：%T",i)
    case int:
         fmt.Println("x是int型")
	case float64:
		fmt.Println("x是float64型")//会输出	  
    case func(int) float64:
		fmt.Println("x是func(int)型")
	case bool,string:
		fmt.Println("x是bool型或者string型")		 		
	default:
		fmt.Println("未知")
	}

案例:

1).使用switch把小写类型的char型转为大写（键盘输入）。只转换a,b,c,d,e,其他的输出“Other”

func main() {
	//1，使用switch将小写字符改为大写字母
	var char byte
	fmt.Println("请输入相应的字符")
	fmt.Scanf("%c",&char)
	switch char{
	case 'a':
		fmt.Println("A")
	case 'b':
		fmt.Println("B")
    case 'c':
		fmt.Println("C")
	case 'd':
		fmt.Println("D")
	case 'e':
		fmt.Println("E")
	default :
	fmt.Println("other")						
	}

2)对学生成绩大于60分的，输出”合格"。低于60的输出“不合格”。（注：输入的成绩不能大于100）

 var score float64
    fmt.Println("请输入成绩")
	fmt.Scanln(&score)
	switch int(score / 60){
	    case 1:
			fmt.Println("及格")	
		case 0:
			fmt.Println("不及格")	
	    default:
			fmt.Println("输入有误...")

3）根据用户指定月份，打印该月份所属的季节。3,4,5.春季 6,7,8夏季 9,10,11秋季 12,1,冬季

//3,根据用户指定月份，打印该月份所属的季节。
	// 3,4,5.春季 6,7,8夏季 9,10,11秋季 12,1,
	// 冬季
	var month byte
	fmt.Println("请输入月份")
	fmt.Scanln(&month)
	switch month {
	case 3,4,5:
		fmt.Println("春季")
	case 6,7,8:
		fmt.Println("夏季")	
	case 9,10,11:
		fmt.Println("秋季")	
	case 12,1,2:
		fmt.Println("冬季")	
	default:
		fmt.Println("您输错了月份")	
	}

switch和if的比较

1）如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用switch语句简洁高效

2）其他情况：对区间判断和结果为bool类型的判断，用if if的使用范围更广

3.循环控制

for循环控制

基本语法

for循环变量初始化;循环条件;循环变量迭代{
      循环操作（语句）
}

对上面的语法格式说明

1)对for循环来说，有四个要素

2)循环变量初始化

3)循环条件

4)循环操作（语句），有人也叫循环体。

5)循环变量的迭代

6)for循环执行的顺序

for循环执行的顺序说明

1）执行循环变量的初始化，比如 i :=1

2)执行循环条件，比如 i<=n

3)如果循环条件为真就执行循环操作

4)执行循环变量迭代

5)反复执行 2 3 4 步骤，直到循环条件为false就退出for循环

案例

编写一个程序循环十次"你好刘承传"

package main

import (
	"fmt"
)
func main(){
	for i :=1;i<= 10;i++{
		fmt.Println("你好刘承传",i)
	}
}

for循环的注意事项和细节说明

1）循环条件时返回一个布尔值的表达式

2）for循环的第二种使用方式

for 循环判断条件 {
   //循环执行语句
}
将变量初始化和变量迭代写到其他的位置
案例：
//for循环的第二种写法
	j := 1 //循环变量初始化
	for j <= 10 { //循环条件
		fmt.Println("你好刘承传",j) //循环体
		j++  //循环变量的迭代
	}

3）for循环的第三种使用方法

for {
     //循环执行语句
}
上面的写法等价for ; ; {}是一个无限循环，通常需要配合break语句使用
//for循环的第三种写法,这种写法通常会配合break进行使用
	k :=1
	for { //此处等价 for ; ; ;{}
		if k <= 10{
		fmt.Print("helllo\n")
		}else{ //k>10时就break跳出
			break //break就是跳出整个for循环
		}
		k++
	}

for的注意事项和细节说明

4）Golang提供for-range的方式，可以方便遍历字符串和数组（注：数组的遍历）

way1传统方式进行遍历	
str := "hello world!"
for i :=0;i<len(str);i++{
fmt.Printf("i=%d val=%c\n",i,str[i])
}

way2for-range方式进行遍历
func main(){
str :="hello,world!北京"
for index,val :=range str {
fmt.Printf("index=%d val=%c\n",index,val)
}

注意：for-range在遍历字符串时，是按照字符来遍历的，而不是按照字节来的，请注意这点
}

上面的细节讨论：

如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误。会出现乱码，原因是对字符串的遍历是按照字节进行遍历的，而一个汉字在utf8编码对应的是3个字节

如何解决，需要将str []str切片

//传统方式对字符串进行切片
	str2 := []rune(str) //把str转成了[]rune
	for i :=0;i<len(str2);i++{
		fmt.Printf("i=%d val=%c\n",i,str2[i])
	}

对应for-range遍历字符串时，是按照字符串来遍历的，而不是按照字节来的。请注意这一点

for循环练习题

1）打印1~100之间所有是9的倍数的整数的个数及总和

func main(){
	var ge int = 0
	var sum int = 0
	for i :=1;i<=100;i++{
		if i % 9 ==0{
			ge++
			sum = sum + i
		}
	}
	fmt.Printf("1~100之间是9的倍数额整数个数为%d,总和为%d",ge,sum)
}

2）完成下面的表达式输出

//第二题
	var n int =6
	for i :=0;i<=n;i++{
		fmt.Printf("%v + %v= %v\n",i,n-i,n)
	}

while 和do…while的实现

Go语言没有while和do …while语法，我们可以使用for循环来实现其使用效果

1）for循环实现while效果：先进行判断条件是否符合在进行循环输出

循环变量初始化
for {
    if 循环条件表达式{
     break  //跳出for循环
    }
    循环操作（语句）
    循环变量迭代
}
说明：

1. for循环是一个无限循环
2. break语句就是跳出循环

使用上面的while循环输出十句“hello world”

//使用while方式输出十句"hello world"
	//循环变量初始化
	var i int = 1
	for {
		if i>10 {
			break  //跳出循环结束过程
		}
		fmt.Println("hello world",i)
		i++  //循环变量的迭代
	}

使用do…while实现:先进行循环当条件不符合时就跳出循环

语法

循环变量初始化
for {
   循环操作(语句)
   循环变量迭代
   if 循环条件表达式{
     break //跳出for循环
   }
}

对上图的说明

1. 上面的循环是先执行，再判断，因此至少执行一次
2. 当循环条件成立后，就会执行break,break就是跳出for循环，结束for循环

案例演示使用上面的dowhile实现输出十句helloworld

//使用do while的形式进行实现
var i int  = 1
	for {
		fmt.Println("hello world" ,i)
		i++ //循环变量进行迭代
		if i>10{
			break //跳出for循环
		}
	}

多重循环的控制

介绍：

1）将一个循环放在另一个循环体内，就形成了嵌套循环，在外边的for称为外层循环在里面的for循环称为内层循环（建议一般使用两层，最多不得超过三层）

2）实质上，嵌套循环就是把内层循环当作外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层循环的当次循环，开始下一次循环

3）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=nm次

应用实例

1》统计3个班级成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分（学生成绩从键盘输入）

//案例1
	/*
	 1)统计3个班的成绩情况，每个班5名同学，
	 求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入
	 ）
	 分析实现思路
	 1.统计一个班成绩情况，每个班有5名同学，求出这个班的平均分
	 2.学生数就5个 
     3.声明一个变量sum统计班级的总分
	 4.定义一个变量统计总成绩得出所有学生的平均分

	 分析思路2
	 要统计三个班，走三次
	 分析思路3
	 1,将代码激活
	 2.定义两个变量表示班级的个数和班级的人数

	 代码实现
	*/
	var classNum int =2
	var stuNum int = 5
	var totalSum float64 = 0.0
	for j :=1;j <=classNum;j++{
	sum := 0.0
	for i := 1;i<=stuNum;i++{
		var score float64
		fmt.Printf("请输入第%d个班的第%d个学生成绩\n",j,i)
		fmt.Scanln(&score)
        //累计总分
		sum += score
	}
	fmt.Printf("第%d个班级的平均分是%v\n",j,sum / float64(stuNum))
	//将总分进行累加
	totalSum += sum
	fmt.Println("  ")
 }
 fmt.Printf("各个班级的总成绩是%v各个班级的平均分是%v",totalSum,totalSum/ float64(classNum * stuNum))
}

2》统计三个班及格人数，每个班有5名同学

func main(){
	//案例1
	/*
	 1)统计3个班的成绩情况，每个班5名同学，
	 求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入
	 ）
	 分析实现思路
	 1.统计一个班成绩情况，每个班有5名同学，求出这个班的平均分
	 2.学生数就5个 
     3.声明一个变量sum统计班级的总分
	 4.定义一个变量统计总成绩得出所有学生的平均分

	 分析思路2
	 要统计三个班，走三次
	 分析思路3
	 1,将代码激活
	 2.定义两个变量表示班级的个数和班级的人数

	 //分析思路3统计班级及格人数
	 1,声明一个变量用于保存及格人数


	 代码实现
	*/
	var passc int = 0
	var classNum int =2
	var stuNum int = 5
	var totalSum float64 = 0.0
	for j :=1;j <=classNum;j++{
	sum := 0.0
	for i := 1;i<=stuNum;i++{
		var score float64
		fmt.Printf("请输入第%d个班的第%d个学生成绩\n",j,i)
		fmt.Scanln(&score)
        //累计总分
		sum += score
		//判断分数是否及格
		if score >=60{
          passc ++
		}
	}
	fmt.Printf("第%d个班级的平均分是%v\n",j,sum / float64(stuNum))
	//将总分进行累加
	totalSum += sum
	fmt.Println("  ")
 }
 fmt.Printf("各个班级的总成绩是%v各个班级的平均分是%v及格人数是%v",totalSum,totalSum/ float64(classNum * stuNum),passc)
}

打印一个矩形

//矩形
for i := 1;i<=5;i++{
	for j :=1;j<=5;j++{
      fmt.Printf("*")
	}
	fmt.Println(" ")
 }
 //左侧直角三角形
 for i := 1;i<=5;i++{
	for j :=1;j<=i;j++{
      fmt.Printf("*")
	}
	fmt.Println(" ")
 }
//打印金字塔

案例2打印金字塔经典案例
案例分析
代码思路
1.打印一个金字塔
 */
 var toleve int =9
 for i := 1;i<=toleve;i++{
	//在打印星号前打印空格
	for k :=1;k<=toleve-i;k++{
		fmt.Print(" ")
	}
	for j :=1;j<=2*i-1;j++{
      fmt.Printf("*")
	}
	fmt.Println(" ")
 }
}

打印空心金字塔

//打印空心金字塔
 /*
   *
  * *
  ****
  分析：在我们给每行打印*号时需要考虑一个问题是打印*还是打印空格
  每层的第一个和最后一个就是打印星星，其他的都打印空格
  分析到例外情况，最底层是全部打印星星
 */
 var toleve int =9
 for i := 1;i<=toleve;i++{
	//在打印星号前打印空格
	for k :=1;k<=toleve-i;k++{
		fmt.Print(" ")
	}
	//在空格后面打印星星
	for j :=1;j<=2*i-1;j++{
      if j ==1 || j==2 * i -1 || i==toleve{
		fmt.Printf("*")
	  }else{
		fmt.Print(" ")
	  }
	}
	fmt.Println(" ")
 }

打印九九乘法表

/*
 打印九九乘法表

 
 */
 for i:=1;i<=9;i++{
	for j:=1;j<=i;j++{
		fmt.Printf("%v * %v= %v  ",i,j,i*j)
	}
	fmt.Println(" ")
 }
}

4.跳转控制语句

break

看需求：

随机生成1-100的一个数，直到生成了99这个数，看看你一共用了几次

分析：编写一个无限循环的控制，然后不停地随机生成数，当生成了99时，就退出这个无限循环==》break

package main

import (
	"fmt"
	"math/rand"
	"time"
)
func main() {

    //为了生成一个随机数，还需要个rand设置一个种子
	//time.Now().Unix():返回一个从1970:01:01的0分0秒到现在的秒数
	//rand.Seed(time.Now().Unix())
	//如何生成1-100的整数
	//n := rand.Intn(100) +1 //[0-100]故加一变成那个[1 100]
   // fmt.Println(n)

	/*
   思路：
   编写一个无限循环控制，然后不停的随机生成数，当生成了99时
   就退出这个无限循环==>break
	*/
	var count int = 0
	for {
		rand.Seed(time.Now().UnixNano())
		n := rand.Intn(100) +1 
		fmt.Println("n=",n)
		count ++
		if(n ==99){
			break //跳出for循环
		}
	}
	fmt.Printf("生成99一共使用了%v次",count)
     
}

基本介绍:

break语句用于终止某个语句块的执行，用于中断当前for循环或跳出switch语句

基本语法

( ......
break;
  ......
)

注意事项或细节说明

1）break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是那一层语句块

2）标签的基本使用

label1:{...
label2:  {...
label3:    {...
           break label2;
           ....

          }
        }
      }

案例代码:

//这里演示一下指定标签的形式使用 break
	label2:
    for i := 0; i < 4; i++{
		//label1:  //设置标签
		for j := 0; j < 10; j++{
			if j ==2 {
				//break //break默认会跳出最近的for循环
			
			    //break label1
			    break label2
			}
			fmt.Println("j=",j) //j=0 j=1
		}
	}

对案例的说明：

• break默认跳出最近的for循环
• break后面可以指定标签，跳出标签对应的for循环

break语句练习题

1)100以内的数求和，求出当和第一次大于20的当前数。

func main(){
	sum := 0
	for i :=1;i <=100; i++ {
		sum +=i //求和
		if sum > 20 {
			fmt.Println("当sum大于20时,这个数是：",i)
			break
		}
	}

2）实现登录验证，有三次机会，如果用户名为“张无忌”，密码"888"提示登录成功，否则提示还有几次机会

//实现登录验证，有三次机会，如果用户名为“张无忌密码为888就提示登录成功
	//否则就提示还有几次机会
	var name string
	var passwd string
	var loginla int = 3
	for i:=1;i<=3;i++{
		fmt.Println("请输入姓名")
		fmt.Scanln(&name)
		fmt.Println("请输入密码")
		fmt.Scanln(&passwd)
		if name !="张无忌" || passwd != "888"{
			loginla --
			fmt.Printf("登录失败，你还有%v次机会\n",loginla)
			}else{
			fmt.Println("恭喜你登录成功")
			break
		}
	}

continue

基本介绍：

1）continue语句用于结束本次循环，继续执行下一次循环

2）continue语句出现在多层嵌套循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的break标签的使用的规则一样

基本语法

{
 ...
 continue;
 ...
}

案例分析continue的使用

func main() {
	/*
    continue案例
	这里演示一下指定标签的形式来使用
	*/
 //label2
 for i := 0; i<4; i++{
 //label1:设置一个标签
for j :=0; j<10 ; j++{
	if j ==2 {
		continue
	}
	fmt.Println("j=",j)
   }
  
 }
}

输出4次134…9，但是每次都没有2在其中。

continue输出1~100的奇数

//1~100的奇数
for i:=1; i<=100; i++{
	if i%2!=0{
		fmt.Println(i)
	}else{
		continue
	}
}

从键盘读入个数不确定的整数，并判断读入额正数和负数额个数，输入为0时结束程序for循环break continue完成

func main() {

	var posicount int
	var negacount int
	var num int
	for {
		fmt.Println("请输入一个整数")
		fmt.Scanln(&num)
		if num ==0 {
		break //终止for循环
		}
		if num >0 {
			posicount ++
			continue //结束本次循环，进入下一次循环
		}
			negacount ++
			
	}
	fmt.Printf("正数的个数是%v，负数的个数是%v",posicount,negacount)

goto

介绍：

1）Go语言的goto语句可以无条件地转移到程序中指定的行

2）goto语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能

3）在Go程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解与调试程序都产生困难

基本语法

goto label
...
label:statement

func main(){
	//演示goto的使用
	fmt.Println("ok1")
	goto lable1
	fmt.Println("ok2")
	fmt.Println("ok3")
	fmt.Println("ok4")
	lable1:
	fmt.Println("ok5")
	fmt.Println("ok6")
	fmt.Println("ok7")
}
//运行结果为：
ok1
ok5
ok6
ok7

return

return使用在方法，表示跳出所在的函数或方法

func main(){
for i :=1; i<=10; i++{
if i ==3{
return
}
fmt.Println(i)
}
fmt.Println("helloworld")
}

说明：

1）如果return 是在普通的函数，则表示跳出这个函数，即不再执行这个函数

}

案例分析continue的使用

```go
func main() {
	/*
    continue案例
	这里演示一下指定标签的形式来使用
	*/
 //label2
 for i := 0; i<4; i++{
 //label1:设置一个标签
for j :=0; j<10 ; j++{
	if j ==2 {
		continue
	}
	fmt.Println("j=",j)
   }
  
 }
}

输出4次134…9，但是每次都没有2在其中。

continue输出1~100的奇数

//1~100的奇数
for i:=1; i<=100; i++{
	if i%2!=0{
		fmt.Println(i)
	}else{
		continue
	}
}

从键盘读入个数不确定的整数，并判断读入额正数和负数额个数，输入为0时结束程序for循环break continue完成

func main() {

	var posicount int
	var negacount int
	var num int
	for {
		fmt.Println("请输入一个整数")
		fmt.Scanln(&num)
		if num ==0 {
		break //终止for循环
		}
		if num >0 {
			posicount ++
			continue //结束本次循环，进入下一次循环
		}
			negacount ++
			
	}
	fmt.Printf("正数的个数是%v，负数的个数是%v",posicount,negacount)

goto

介绍：

1）Go语言的goto语句可以无条件地转移到程序中指定的行

2）goto语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能

3）在Go程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解与调试程序都产生困难

基本语法

goto label
...
label:statement

func main(){
	//演示goto的使用
	fmt.Println("ok1")
	goto lable1
	fmt.Println("ok2")
	fmt.Println("ok3")
	fmt.Println("ok4")
	lable1:
	fmt.Println("ok5")
	fmt.Println("ok6")
	fmt.Println("ok7")
}
//运行结果为：
ok1
ok5
ok6
ok7

return

return使用在方法，表示跳出所在的函数或方法

func main(){
for i :=1; i<=10; i++{
if i ==3{
return
}
fmt.Println(i)
}
fmt.Println("helloworld")
}

说明：

1）如果return 是在普通的函数，则表示跳出这个函数，即不再执行这个函数

2）如果return在main函数，表示终止main函数，也就是说终止程序