Java三种程序基本结构
 
今天我们了解下Java的三种程序基本结构
 
理解什么是基本结构
 
主要分为 ：1. 顺序结构 2. 选择结构 3. 循环结构
 
一丶顺序结构
 
顺序结构就是程序从上到下一行一行的执行代码，没有判断和中转。（如下图：）
 
 我们最常见的程序如：
 
	
	我们输出两行语句分别是:Hello World 和 Hello Java 他们都是从上到下顺序执行。
	没有任何分叉选择和循环，也就是我们最常见的顺序执行结构。
1.  Public class HelloWorld{
2.  public static void main(String[] args){
3.
3.  	System.out.println("Hello,World");
5.
4.  	System.out.println("Hello,Java")
5.	
6.	}
7.	}

 
二丶选择结构
 
有选择性的执行或者跳过指定代码 （如下图）
 
 
Java的选择结构使用选择语句来实现：
 
1 if语句
 
	if 选择语句的四种形式：

	有选择性的执行或者跳过指定代码
1.	if(条件){…}
	判断是否为真如果不为真则直接执行else语句
2.	if(条件){…}else{…}
	先判断是否为真如果不为真则执行else if 再次判断是否为真 如果都不为真则执行else语句
3.	if(条件){…}else if(条件){…}else{…}
	if中嵌套一个if 如果外层if为真则运行内层的if 如果外层不为真则运行else
4.	if(条件){ if(条件){...} } else {...}

 
运行顺序如下图：
 
 
  	简单的if语句，java成绩如果大于60，奖励一颗糖
1. 	//简单的if语句：
2. 	//成绩如果大于60  给奖励
3. 	int score = 10;
4. 	if(score>60){
5. 	System.out.println("给颗糖");
}
	因为10不大于60所以不打印任何东西。如果大于60则打印:给颗糖
 
2 switch语句
 
表达式expr的值必须是下述几种类型之一：
 byte、short、int、char、enum(枚举)；java7之后可以是String。
case子句中的值const 必须是常量值(或final的变量)，case中的值不能是一个范围。
所有case子句中的值应是不同的,否则会编译出错。
default子句是可选的（不是必须的）。
break语句用来在执行完一个case分支后使程序跳出switch语句块；否则会继续执行下去。
 
语法结构：
 
	//switch只适合做等值判断。
	//语法结构：
	switch(表达式){
		case 常量1:		代码块1;		break;
		case 常量2 :	代码块2;		break;
		case 常量3 :	代码块3;		break;
					...
		default:		默认代码块;	break;
}
 
简单的switch语句：
 
1.	int count = 1;
2.	switch(count){ 
3.		case 1:
4.		System.out.println("奖励iphonexs");
5.		break;
6.		case 2:
7.		System.out.println("奖励xiaomi");
8.		break;
9.		case 3:
10.		System.out.println("奖励200元");
11.		break;
12.		default:
13.		System.out.println("给个彩票");
14.		break;
15.	}
	最后输出结果为:奖励iphonexs
 
3丶循环语句
 
循环就是在循环条件满足的情况下，反复执行特定代码。
 
如果当我们要打印100次helloworld?
 或者我们想实现1-100的和?
 1+2+3+4+5…
 int sum = 0;
 sum = sum + 1;
 sum = sum + 2;
 sum = sum + 3;
 sum = sum + 4;
 sum = sum + 5;
 可以发现有一些是相同的内容。这些相同的内容我们就可以采用循环的方式来实现。
 
1.循环的分类
 
while 循环
do/while 循环
for循环
 
2.循环的组成部分
 4. 初始化部分:对循环变量赋初值
 5. 循环条件部分:判断循环变量是否超出某个界限
 6. 循环体部分:要循环执行的具体逻辑.
 7. 更新循环变量部分:修改循环变量的值
 
while循环
 while (循环条件) {语句块(循环体)}
 
先判断循环条件表达式的值。若为true.则执行循环体,然后再次判断条件并反复执行，直到条件不成立为止。特点：先判断再执行。
 
	打印输出5次helloworld
1.// 初始化部分
8.	int count = 0;
9.	// 2循环条件
10.	while(count<5){// 1 2 3
11.  //3循环体
12.	System.out.println("hello world");
13.  //4更新循环变量
14.	count++;
15.	}
16.	最后输出五次Helloworld	
 
do-while循环
 do {语句块} while(条件表达式) ;
 
先执行语句,再判表达式的值,若为true,再执行语句,否则结束循环。
 特点：先执行，再判断。
 
1. 打印三次Hello World！
2. // 1 初始化部分
3. int i = 0;
4. do{
5. // 2 循环体
6. System.out.println("Hello World!");
7. // 4 循环变量变化部分
8. i++;
9. }while(i<3);// 3 循环条件
10. 最后打印出三次Hello World！ 
 
while 和 do-while的区别
 while 和 do/while 的区别:
 1 执行过程不同
 while 先执行循环条件，然后再执行循环体，一句话：先判断，再执行
 do/while 先执行循环体 然后再执行循环条件，一句话：先执行，再判断
 2 当第一次不满足循环条件的情况下 while循环不能执行循环体, do while 可以执行一次
 
for循环
 for (表达式1 [循环变量初始化]; 表达式2 [循环条件判断]; 表达式3 [更新循环变量])｛
 循环体
 ｝
 
首先计算表达式1,接着计算表达式2,若表达式2的值为true,则执行循环体,接着计算表达式3,再判断表达式2的值.
 依此重复下去,直到表达式2的值为false。
 特点：先判断，再执行。
 
1.	打印100以内 能被4整除不到能被7整除的数据，每行打印6个
2.	int count = 0;
3.	for(int i = 1; i<=100; i++){
4.	if(i%4==0 && i%7!=0){
5.	System.out.print(i+"\t");
6.	count++;// 6
7.	if(count%6==0){
8.	System.out.print("\n");
9.	}
10.	}
11.	}
12.	最后打印出100以内所有能被4整出但是不能被7整除的数但是每行只打印6个
 
在这里我只写了几个简单的代码展示效果，想要加深学习还是要去网上找对应的题去反复练习才能加深印象熟练的运用。
 
还是那句话：每一个成功者都有一个开始。勇于开始,才能找到成功的路。
 让我们一起努力，明天才会更好！ 加油！

顺序、选择和循环语句（程序的三种基本控制结构）
 
复合语句
 
1、在了解程序的三种基本控制结构之前，我们先了解以下什么是复合语句，即块语句。
 
2、与C语言及其他语言不同，Java语言的复合语句是以整个块区为单位的语句，所以又称为块语句。复合语句由开括号“ { ”开始，闭括号“ } ”结束。
 
3、在前面的学习中我们已经接触到了这种复合语句，例如：在定义一个类或方法时，类体就是以“ { ”作为开始，“ } ”作为结束的标记的，方法体同样也是以“ { ”作为开始，“ } ”作为结束的标记的。复合语句中的每个语句都是从上到下被执行。复合语句都是以整个块区为单位，能够用在任何一个单独语句可以用到的地方，并且在复合语句中还可以嵌套复合语句，例如：在类体里面嵌套方法体或内部类。
 
4、在使用复合语句时要注意，复合语句为局部变量创建了一个作用域，该作用域为程序的一部分，在该作用域中某个变量被创建并能够被使用。如果在某个变量的作用域外使用该变量，则会出现错误。
 
package com.zyt.lesson01;

public class Demo {
	public static void main(String args[]) {
		int num = 0;
		for (int i = 1; i <= 10; i++) {
			num += i;
		}
		System.out.println(num);
	}
}
//  输出结果：55  
 
package com.zyt.lesson01;

public class Demo {
	public static void main(String args[]) {
		for (int i = 1, num = 0; i <= 10; i++) {
			num += i;
		}
		System.out.println(num);
	}
}
//  报错
/*  Exception in thread "main" java.lang.Error: 无法解析的编译问题：
	num cannot be resolved to a variable

	at com.zyt.lesson01.Demo.main(Demo.java:9)  */
//  在for循环语句中声明的局部变量num，其作用域在for循环体中。在循环体之外使用num将会报错。
 
选择语句（条件语句）
 
我们都知道，计算机的主要功能是提供用户计算的功能，但在计算的过程中会遇到各种各样的情况，针对不同的情况会有不同的处理方法，这就要求程序开发语言要具有处理决策的能力。
 
一、if 条件语句
 
1、决策分支
 
决策：就是人们为某件事拿主意，下决心做出合理的选择的过程
 
2、if 语句
 
Java中处理决策的方法之一：if 语句
 
第一种形式的判断语句
 
//  语法一：
if(布尔表达式){
    语句;
}
//如果这个布尔表达式的结果是true，则执行大括号内的语句；如果这个布尔表达式的结果是false，则跳过大括号内的语句，而继续执行大括号外的语句。


//  语法二：
if(布尔表达式)
    语句;
//如果布尔表达式的结果是true，则执行圆括号后面的第一个分号内的语句；如果布尔表达式的结果为false，则跳过第一个分号内的语句，继续执行后面的语句。
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-92EQ0HeE-1607846568787)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图1.jpg)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eLVwTbCs-1607846568790)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图2.jpg)]
 
常见的错误：
 
 
if（表达式）的后面多加了一个分号
 
if（表达式）; { }
 
if（表达式）; 
{  
   语句;
		  }
 
这样的写法编辑器不会报错，但是是错误的，这时候 if 只会控制分号前的语句，不会控制分号后面花括号内的语句。
 
 
没加大括号{ }
 
if（表达式）
   语句;
   语句;
 
这样的写法编辑器不会报错，但也是错误的。这时候 if 只能控制第一个分号前的语句，而控制不到第二个分号前的语句。
 
 
在花括号后面加分号
 
if（表达式） 
{  
   语句;
		  };
 
这样的写法编辑器会报错，这样的语法是错误的
 
 
第二种形式的判断语句
 
//  语法
if(布尔表达式){
    语句一;
}else{
    语句二;
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nTfsOqjg-1607846568791)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图3.jpg)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y65b5x5Q-1607846568793)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图4.jpg)]
 
实例：（流程图如上）
 
public class Demo{
    public static void main(String args[]){
        int balance = 500;
        if(balance==500){
            System.out.println("买豪车");
        }else{
            System.out.println("买自行车");
        }
        System.out.println("吃饭睡觉");
    }
}
//  输出结果：吃饭睡觉
 
常见的错误：
 
 
未加大括号{ }
 
else 之前若有两个 if 且都没加大括号，则这个 else 会匹配离它最近的那个 if
 
if()
    if()
        else{
		
        }
 
 
else 不能单独使用，必须和关键字 if 一起使用
 
 
第三种形式的判断语句
 
//  语法
if(表达式 1){
	语句 1;
    ......
    
}else if(表达式 2){
	语句 2;
    ......

}else if(表达式 m){
	语句 m;
    ......

}else{
	语句 n;
    ......        
}
 
3、在书写判断语句时要遵循一定的书写规范，否则容易出现错误
 
布尔表达式书写规范
 
boolean flag = flase;
if(flag==true)		
//这样书写没有错误，但如果不注意漏写一个"="就会出现错误，但不会报错。
//因此更规范的写法应该为：if(flag) 和 if(!flag)
 
4、if 判断语句的总结
 
 
表达式：关系表达式或逻辑表达式
 
 
表达式的运算结果应该是真或者假
 
真：执行该语句
 
假：跳过该语句，执行下一条语句
 
 
” 语句 “可以是单语句也可以是复合语句。
 
 
else if 可以有多条。
 
 
if 和 else if 都需要判断表达式真假，else 不需要，else if 和 else 必须配合 if 一起使用，不能单独使用。
 
 
二、Switch 多分支语句
 
在编程中经常会碰到这样一种问题，就是我们需要判断一个变量是否等于某一个值，如果不等于，再用另一个值来与它做对比，比如我们要实现给某一个同学打评语的功能
 
char grade = 'B';
if(grade=='A'){
    System.out.println("真棒");
}
if(grade=='B'){
    System.out.println("做的不错");
}
if(grade=='C'){
    System.out.println("再接再厉");
}
/*
进行多次判断实现多选一
代码过于繁杂
每一个判断语句都要测试
容易混乱
*/
 
如果需要写几十个 if 语句，维护起来将会非常的困难，为了简化这种多层判断的开发效率，Java提供了Switch语句
 
1、
 
Switch中用于判断的参数，可以是byte、short、int、String、枚举
 
！ String和枚举是在 Java 7 之后才允许的，现在很多的公司做项目都用的是 JDK 1.6 ，所以不是很推荐使用字符串作为switch的参数
 
long、float、double 类型的参数是不能放在 Switch 中的
 
2、
 
default 的位置不固定，可以放在 switch 语句块中的任何一个位置，只有在所有的 case 都无法匹配的情况下，才会执行 default 之后的语句
 
default 在 switch 语句块是可写可不写的
 
String name = "张三";
switch(name){
    default :
        System.out.println("查无此人");      
    case "张三" :
        System.out.println("张三报道！"); break;
    case "李四" :
        System.out.println("李四报道！"); break;
    case "王五" :
        System.out.println("王五报道！"); break;
}
//输出结果：张三报道！
 
String name = "张三";
		switch (name) {
		default:
			System.out.println("查无此人");
		case "张三":
			System.out.println("张三报道！");
		case "李四":
			System.out.println("李四报道！");
		case "王五":
			System.out.println("王五报道！");
/*
输出结果：
张三报道！
李四报道！
王五报道！
*/
String name = "张三";
		switch (name) {
		case "张三":
			System.out.println("张三报道！");
		case "李四":
			System.out.println("李四报道！");
		case "王五":
			System.out.println("王五报道！");
		default:
			System.out.println("查无此人");
		}    
/*
输出结果：
张三报道！
李四报道！
王五报道！
查无此人
*/                
 
3、
 
break 用于跳出 switch 语句，也是是可写可不写的
 
//语法
Switch(用于判断的参数){
    case 常量表达式 1 :  语句 1;   break; 		//break是用于跳出语句的，可以不写
    case 常量表达式 2 :  语句 2;   break;
    ......
    case 常量表达式 n :  语句 n;   break;
    default :  语句 n+1;   break;		//default也是可不写的
}
 
4、
 
switch 语句的执行顺序：
 
从表达式值等于某个 case 语句后的值开始，它下方的所有语句都会被运行，直到遇见一个 break 为止
 
实例：
 
public class Demo{
    public static void main(String args[]){
        int score = 10;
        switch(score){
            case 10: 
            case 9: System.out.println("成绩为优");  break;
            case 8: System.out.println("成绩为良");  break;
            case 7:
            case 6: System.out.println("成绩为中");  break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0: System.out.println("成绩为差");  break;
            default : System.out.println("成绩无效");  break;
        }
    }
}
//输出结果：成绩为优
 
int i;
for (i = 0; i < 3; i++) {
    switch (i) {
        case 0:
            printf("%d", i);
        case 2:
            printf("%d", i);
        default:
            printf("%d", i);
    }
}
//输出结果：000122
 
循环语句
 
do while 语句的执行效率比 while 语句高
 
一、While循环语句
 
1、while语句也称条件判断语句，它的循环方式为利用一个条件来控制是否继续反复执行这个语句
 
2、语法
 
while(条件表达式){		//返回布尔值，判断是否继续执行语句
    执行语句;		//可被循环执行的语句
}
 
实例：
 
//用计算机循环计算从1加到100的累加
public class Demo{
    public static void main(String args[]){
        int sum = 0;
        int i = 1;
        while(i<=100){
            sum+=i;
            i++;
        }
        System.out.println(sum);
    }
}
//输出结果：5050
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jUHIdheF-1607846568795)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图6.jpg)]
 
3、三个注意！
 
表达式不允许为空
表达式不应该是常数（true 或 false），这样会进入死循环
循环体中必须要有改变条件表达式值的语句，否则将成为死循环
 
二、do while循环语句
 
1、do while 循环语句与 while 循环语句类似，它们之间的区别是 while 语句为先判断再执行，do while 语句为先执行，再判断。也就是说，do while 语句中，{ }的程序段至少要被执行一次。
 
2、语法
 
do{
    执行语句;
}while(条件表达式);
 
3、do while 语句与 while 语句的一个明显区别是，do while 语句在结尾处多加了一个分号
 
根据do while 循环语句的语法特点总结出的do while 循环语句的执行过程
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Oa7uXbB0-1607846568796)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图5.jpg)]
 
4、当我们想使用某个社交网站时，都会要求我们登录或注册新账户，为了防止用户手误，都会要求我们输入两次密码。如果两次密码不一致，则会提示用户，两次输入的密码不一致，请重新输入，用户就会重新输入密码了。要实现这个功能，需要先让用户输入密码，然后系统再做判断。如果条件不符合，就要求用户重复执行输入密码的操作，我们可以发现，注册的过程中有两个特点：
 
先输入密码，再做判断
如果判断一直假，则循环执行同一逻辑
 
此时，如果使用 while 循环语句来书写代码，不仅需要在循环外对输入的信息做判断，还要在循环内也对输入的信息做判断，这样重复的代码，会使程序笨重有余，不过我们可以使用 do while 语句完美的解决这个问题。
 
//密码输入
public class Demo{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);		//创建一个扫描器
        String pwd1 = "0";
        String pwd2 = "-1";
        
        do{
            System.out.println("请输入密码：");
            pwd1 = sc.nextLine();
            System.out.println("请再次输入密码：");
            pwd2 = sc.nextLine();
            if(!pwd1.equals(pwd2)){
                System.out.println("您两次输入的密码不一致，请重新输入！");
            }while(!pwd1.equals(pwd2));
            System.put.println("设置密码成功！");
        }
    }
}
 
5、while 和 do while 的比较
 
do while 的执行效率比 while 要高
 
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dk260RHg-1607846568797)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\比较.jpg)]
 
public class Demo{
	public static void main(String args[]){
        int i=0,j=0;
        System.out.println("j="+j);
        while(i>1){
            j++;
        }
        System.out.println("j="+j);
    }
}
/*
输出结果：j=0
    	j=0
*/
public class Demo{
	public static void main(String args[]){
        int i=0,j=0;
        System.out.println("before while j="+j);
        do{
            j++;
        }while(i>1);
        System.out.println("after while j="+j);
    }
}
/*
输出结果：before while j=0
    	after while j=1
*/    
 
三、for循环语句
 
for 循环是 Java 程序设计中最有用的循环语句之一。一个 for 循环可以用来重复执行某条（或多条）语句，直到某个条件得到满足。在 Java 5以后增加了 foreach 语法。
 
1、语法
 
for(初始化表达式1;布尔表达式2;表达式3){
    语句;
}
 
初始化表达式：只在循环开始前运行一次，常用来做赋值操作，最常用的就是给循环变量赋值
 
布尔表达式：返回布尔值，控制循环是否继续执行
 
表达式：通常是赋值表达式，在完成一次循环之后执行
 
每循环一次，布尔表达式和表达式就会交替执行一次
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SGnMpocu-1607846568798)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图7.jpg)]
 
2、使用 for 循环，计算从 1 加至 100 的和
 
public class demo{
    public static void main(String args[]){
        int sum = 0;
        for(int i=1;i<100;i++){
            sum+=i;	//即sum=sum+i;
        }
        System.out.println("sum="+sum);
    }
}
//输出结果：sum=5050
 
四、foreach循环语句
 
1、语法
 
for(type x:obj){
    引用了x的java语句；
}
 
循环变量 type x，其中 type 为变量类型，x 为变量名，依次将 obj 中的值赋给 x
 
obj : 是一个可以被遍历的集合，例如数组
 
2、
 
遍历：我们可以简单理解为，对数组或集合中的所有元素，逐一访问，依次读取一遍
 
数组：就是相同数据类型的元素按一定顺序排列的集合
 
int arr[] = {7,10,1};
for(int x:arr){
    System.out.print(x);
}
//输出结果：7101

int sum = 0;
int arr[] = {1,2,3,4,...,49,50};
for(int x:arr){
    sum+=x;
}
System.out.println("sum="+sum);
//输出结果：sum=5050
 
3、百钱买百鸡问题
 
鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁、母、雏各几何
 
public class Demo{
	public static void main(String args[]){
        int cock,hen,chick;
        for(cock=1;cock<=20;cock++){
            for(hen=1;hen<=33;hen++){
                for(chick=3;chick<=99;chick+=3)
                    if(cock*5+hen*3+chick/3==100){		//百钱
                        if(cock+hen+chick==100){		//百鸡
                            System.out.println("公鸡："+cock+"母鸡："+hen+"小鸡："+chick);
                        }
                    }
            }
        }
    }
}
 
循环控制
 
循环控制包含两方面的内容，一方面是控制循环变量的变化方式，另一方面是控制循环的跳转。控制循环的跳转需要用到 break 和 continue 这两个关键字，这两条跳转语句的跳转效果不一样，break 是中断跳出循环，continue 是结束当前循环。
 
1、在我们编写复杂代码时，通常会碰到一些特殊的情况，要求我们立即中断循环或忽略某次的循环，这就要求要对循环进行控制，循环控制有两个关键字， break 和 continue
 
2、break 关键字的使用场景
 
while(  ){
    ......
    break;
}
 
do{
    ......
    break;
}while(  );
 
for(......){
    ......
    break;
}
 
switch(  ){
    case 1 :break;
    case 2 :break;
        .....        
}
 
break的作用：中断跳出循环
 
int i = 1;
while(i>0){
    i++;
    System.out.println(i);
    if(i==10)
        break;
}
System.out.println("循环结束");
 
3、Loop 标签
 
可能有的人会有疑惑：break 控制的是内层循环还是外层循环？
 
想要控制这个，我们就要用到 Loop 标签，Loop 标签使 break 具有了指向性，将跳出被 Loop 标记的这个循环
 
未使用 Loop 标签的场景
 
for(int i=0;i<3;i++){
    for(int j=0;j<6;j++){
        if(j==4)
            break;		//跳出内层循环
    }
}
 
使用了 Loop 标签的场景
 
Loop:for(int i=0;i<3;i++){
    for(int j=0;j<6;j++){
        if(j==4)
            break Loop;		//跳出外层循环
    }
}
 
4、continue 关键字的使用场景
 
continue 关键字的使用场景与 break 类似，但不适用于 switch
 
while(...){
    ...
    continue;    
}
 
do{
    ...
    continue;    
}while(...);
 
for(...){
    ...
    continue;    
}
 
continue 关键字的作用：结束当前循环，执行下一次循环
 
for(int i=1;i<=10;i++){
    if(i%2==0)
        continue;
    System.out.println("i="+i);
}
 
continue也可以使用 Loop 标签
 
for(int i=0;i<3;i++){
    for(int j=0;j<6;j++){
        if(j==4)
            continue;
    }
}

Loop:for(int i=0;i<3;i++){
    for(j=0;j<6;j++){
        if(j==4)
            continue Loop;
    }
}

概念
 
在C语言程序中，一共有三种程序结构：顺序结构、选择结构(分支结构)、循环结构；
 
顺序结构，从头到尾一句接着一句的执行下来，直到执行完最后一句；
 
选择结构，到某个节点后，会根据一次判断的结果来决定之后向哪一个分支方向执行；
 
循环结构，循环结构有一个循环体，循环体里是一段代码。对于循环结构来说，关键在于根据判断的结果，来决定循环体执行多少次。C语言循环控制语句是一个基于C语言的编程语句，该语句主要有while循环语句、do-while循环语句和for循环语句来实现循环结构。
 
 
 
但是三种结构并不是彼此孤立 循环中可以有顺序, 选择(分支).  顺序中可以有选择,可以有循环. 选择中也可以有顺序有循环. 一段程序代码往往是这三者相互结合组成的.
 
 
 
1.顺序结构
 
 C语言的顺序结构顾名思义, 就是程序自上而下执行, 没有分支,也没有循环.
 
 
 
#include <stdio.h>

int main(){
    int a = 3, b = 2;
    int sum = a+b;
    printf("a+b=%d\n", sum);    //输出a+b的和
    return 0;
}
 
像上述代码, 程序顺序执行求和a+b并输出, 没有循环也没有分支, 所以上述代码就是一个顺序结构.
 
 
 
 
2.选择(分支)结构
 
C语言选择结构用于判断给定的条件，根据判断的结果来控制程序的流程。
 
在C语言中, 选择结构有两种: 1. if-else语句,  2. switch-case语句;
 
1) if-else 语句
 
写法:
 
 
 
if(条件1){
    //满足条件1执行此代码块
    ...
}else if(条件2){
    //不满足条件1, 满足条件2执行此代码块
    ...
}else{
    //即不满足条件1也不满足条件2 执行此代码块
    ...
}
 
举个栗子, 成绩评级.
 
 
 
#include <stdio.h>

int main(){
    int score = 78; //模拟输入成绩

    if (score >= 90){  //成绩 大于90 A
        printf("A");
    }else if(score >= 80 && score < 90){ // 80-89 B
        printf("B");
    }else if(score >= 70 && score < 80){ // 70-79 C
        printf("C");
    }else if(score >= 60 && score < 70){ // 60-69 D
        printf("D");
    }else{  //小于60 E
        printf("E");
    }

    return 0;
}
 
 
 
else if 可以有0个或多个,  else 只能有0个或1个.
 
如果我们只需判断学生是否及各, 那么我们就可以这样写:
 
 
 
if (score >= 60){
    printf("及格");
}else{
    printf("不及格");
}
 
当然也可以只有if() 没有else ,  只有if() 和 else if ()没有else.
 
2)switch-case 语句
 
在C语言中, 第二种分支结构就是switch-case, 只是用的地方不太多, 因为if语句可以轻松替代switch语句, 只是结构上没switch那么清晰.
 
语法:
 
 
 
switch (变量或表达式){
    case 常量表达式1: 语句块1; break;
    case 常量表达式2: 语句块2; break;
    ......
    case 常量表达式n: 语句块n; break;
    default: 语句块n+1; break;
}
 
还是成绩评级的栗子:
 
 
 
#include <stdio.h>

int main(){
    int score = 78;  //模拟输入
    
    switch(score / 10){ //case匹配的数据就是score/10的结果  
        case 10: 
        case 9: printf("A"); break;
        case 8: printf("B"); break;
        case 7: printf("C"); break;
        case 6: printf("D"); break;
        default: printf("E"); break;
    }

    return 0;
}
 
score/10 得到的整数就是那个阶段的成绩, 我们会发现case 10: 也就是100分匹配后面没有任何的操作, 最主要的是, 没有break;
 
在switch语句中, 如果case匹配到了语句, 那么后面的语句都会执行知道出现第一个break, 或者执行完成.
 
如果我们将上面代码中的break全部去掉.score还是78, 那么输出就会变成 CDE, 也就是匹配到7 然后输出7之后的所有语句,知道碰到break;
 
default相当于else, 其他所有不匹配的情况, 因为一般是放在最下面, 所以default后面的break可以不写.
 
 
 
重点:switch的条件只能是整型和字符型(其实就是字符的ascii码)或者这些类型的表达式,case匹配的只能是整型或者字符型常量或者这两个类型的常量表达式, 也就是case不能匹配变量.
 
 
 
3.循环结构
 
循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。它由循环体中的条件，判断继续执行某个功能还是退出循环。
 
在C语言中有三种循环结构: for循环, while循环, do-while循环.
 
1) for循环
 
写法:
 
 
 
for(表达式1; 表达式2; 表达式3){
    循环体;
}
 
语句1：初值表达式，常用于在循环开始前为循环变量赋初值
 语句2：循环控制逻辑表达式，控制循环执行和结束的条件
 语句3：循环变量修改表达式，常用于修改循环变量,使得结果趋向于循环结束条件.
 
举个栗子:
 
循环输出10个"hello world!!!"
 
 
 
#include <stdio.h>

int main(){
    int i;
    for (i = 1; i <= 10; i++){ //循环10次, i++为 i自增长1
        printf("hello world!!!\n");
    }
    return 0;
}
 
上诉for循环的执行过程:
 
1.执行表达式1, i = 1, 只执行一遍.
 
2. 执行表达式2, 判断 i <=10
 
3.如果表达式2成立, 执行循环体  { printf("hello world!!!\n"); } 否则执行退出循环, 后续步骤都不执行.
 
4.执行完成循环体后,执行表达式3, i++, i的值自动增长1. 回到步骤2去判断.
 
 
 
for循环中的三个表达式都可以为空, 但是一定要写两个分号也就是 for( ; ; ) 这样就代表无限循环, 也就是死循环.不过一般不会这样用.
 
 
 
而for循环常用的是对数组的操作,所以初始值一般是0.
 
 
 
int i;
int Stu[10] = {99, 87, 76, 59, 73, 45, 99, 39, 88, 19}; //班级10个学生的成绩

for(i = 0; i < 10; i++){    //循环10次, 0~9
    printf("学号为:%d, 成绩为: %d\n", i+1, Stu[i]);   //数组下标从0开始
}
 
其实可以发现, 正常的for循环可以很清晰的明白for循环的循环次数.
 
 
 
所以在你很清晰明白这次循环需要循环多少次的时候推荐使用for循环.
 
 
 
2)  while 循环
 
while循环的语法简单易懂
 
 
 
 while(表达式){
        语句块
    }
 
执行过程: 执行表达式, 如果成立执行语句块, 否则退出循环.
 
 
 
while循环也可以和for循环互换.
 
 
 
//for -> while
int i = 0;
while (i < 10){
    //循环体
    i++;
}
//while -> for
for (;l < r;){
}
 
for->while: 没有for循环那么清晰明了的知道循环次数.
 
while->for: 没有while循环那么简单易懂了.
 
所以while循环的一般用法是我们不太清楚循环在什么时候结束, 并且我们也不关心具体的循环次数的时候使用.
 
举个例子: 二分查找
 
 
 
#include <stdio.h> 
 
int main(){  
    int a[10] = {12, 32, 34, 55, 76, 89, 99, 123, 345, 1234}; //递增的数组 
    int l = 0, r = 9, mid; 
    int res = 345;  //查找的目标 
    //二分查找位置 
    while(l <= r){ 
        mid = (l+r)/2; 
        if (res == a[mid]){  //找到了输出位置, 并退出循环. 
            printf("位置: %d\n", mid+1); break; 
        }else if(res < a[mid]){  
            r = mid-1; 
        }else{   
            l = mid+1; 
        } 
    } 
    return 0; 
} 
 
我们只看while循环的内容, while(l<=r)  也就是当l>r时循环退出.
 
 
 
 
 
 
 
和for循环不同的是, 我们并不清楚程序在什么时候会退出, l和r在循环中是在不断变换的.这种情况使用while循环是个不错的选择.
 
 
 
3) do-while循环
 
 
 
do{
    循环体
}while(表达式);
 
和while循环不同的是,do-while循环是先执行一遍循环体,再判断是否满足表达式.
 
 
 
注意: do-while循环最后是有一个分号结尾的.
 
do-while循环的用处也就在先执行一遍循环体再判断, 那么如果我们需要判断的内容必须要执行一遍循环体才能知道的话,那么就可以使用do-while循环.
 
举个例子:
 
 
 
#include <stdio.h>

int main(){
    int t;
    int res = 89;
    do{
        printf("请输入一个数字,输入0退出游戏:");
        scanf("%d", &t);
        if(t == res){
            printf("猜对了!\n");
        }else if (t > res){
            printf("太大\n");
        }else{
            printf("太小\n");
        }

    }while(t != 0);
    return 0;
}
 
虽然这个例子bug很多, 但是我们可以清晰的理解do-while循环的不同, 我们一开始并不清楚t的值, 当我们执行完循环体后才知道t的值,然后做判断.
 
 
 
 
 
三大循环总结:
 
for 循环: 在你很清晰明白这次循环需要循环多少次的时候推荐使用.
 
while循环: 在我们不太清楚循环在什么时候结束, 并且我们也不关心具体的循环次数的时候推荐使用.
 
do-while循环: 如果我们需要判断的内容必须要执行一遍循环体才能知道的话推荐使用.
 
 
 
 
 
 

前言
 
 
 
 
文章中介绍C语言程序执行过程中最基本的三种结构，包括有：顺序结构、分支结构、循环结构。理解和学习程序的执行过程，对于以后学习其他的编程语言，或者程序的调试，程序调Bug都有很好的帮助。
 
 
程序是什么？ 
 所谓的程序，就是一系列遵循一定规则和思想并能够正确完成指定工作的代码（也成为指令序列）。 
 其中，程序的一个部分是描述问题的每一个对象及它们之间的关系，这部分被成为数据结构（我认为程序设计中非常重要的一门课程）。 
 另外的一个部分是对这些对象进行处理的规则，当然这个就是算法。牛X的人，都是数学好的人~~ 
 因此有这么一种说法：程序=数据结构+算法 
 程序设计=数据结构+算法+程序设计方法+语言工具和环境
 
 
顺序结构
 
 
 
 
后面介绍的内容，基本上是基于C程序来介绍，通过实例和注释来解释知识点的重难点和用法。 
 顺序：顾名思义，从上到下、从左到右、从小到大……程序中的顺序结构便是从程序的main()函数入口，一条一条的指令执行，知道遇到程序结束的指令结束程序。
 
 
当然第一个程序必须是：“Hello world”
 
顺序结构程序代码：
 
//载入头文件 std 标准 io输入输出流 
#include<stdio.h>

/*
程序的入口函数 mian()函数 其中()中参数可以省略 
agrc参数表示是程序指令的个数 
agrv指针类型数组保存的是每一条指令在内存中的地址 
*/ 
int main(int agrc,char *agrv[]){

    //定义一个字符串数组 给s初始化的内容是 Hello world!
    char s[] = "Hello world!";
    //将需要输出的内容输出到console控制台 
    printf("%s",s);
    /*
    程序需要返回一个int类型的数据
    程序能正常终止 返回值为 0 异常终止 返回值 1 
    这里正常终止 设置为 0 
    */ 
    return 0;
} 
 
程序执行结果
 
 
 
 
 
整体看一下这个程序
 
 
 
输出结果可以看到“Hello world！”我们希望输出的内容输出到屏幕上了，可以看到程序执行了0.4415s，最后返回的结果是0，和我们的预期一样。
 
 
程序具体的每一句的代码的执行目的代码注释里面有详细解释。其中良好的程序编写人员都会有代码注释的习惯，方便别人阅读和自己回头的理解。这里注释的方式有两种，程序中均有体现。
 
 
程序运行流程：从main()入口函数进入程序，按照顺序的执行方式，一句一句的执行，定义char类型的字符串s，输出s，返回return，程序结束。很好理解。
 
 
分支结构
 
 
 
 
分支结构中需要知道if、else、elseif、switch case的用法
 
 
分支结构程序代码：
 
//载入头文件 std 标准 io输入输出流 
#include<stdio.h>

/*
程序的入口函数 mian()函数 其中()中参数可以省略 
agrc参数表示是程序指令的个数 
agrv指针类型数组保存的是每一条指令在内存中的地址 
*/ 
int main(int agrc,char *agrv[]){

    /*
    顺序结构
    */ 
    //定义一个字符串数组 给s初始化的内容是 Hello world!
    char s[] = "Hello world!";
    //将需要输出的内容输出到console控制台 
    printf("%s\n",s);

    /*
    分支结构 
    */
    int n;
    scanf("%d",&n);
    //if分支语句 括号内部判断是不是真 若为真 执行if内的语句
    //分支语句可以没有else 但有else 一定要有一个if与之对应
    //这里的括号内部判断的是一个数字 C语言中非0的数字均为真  
    if(3)
        printf("1:\t这是一个真语句!\n") ;

    //if -else -elseif 
    //判断输入的n与0的关系并输出 
    if(n>0)
        printf("2:\t%d大于0\n",n);
    else if(n == 0)
        printf("2:\t%d等于0\n",n);
    else
        printf("2:\t%d小于0\n",n);

    //分支嵌套 switch case
    if(n>0)
        printf("3:\t%d大于0\n",n);
    else
    {
        if(n == 0)
            printf("3:\t%d等于0\n",n); 
        else{
            switch(n){
                //若n的值是 -1的情况 
                case -1:
                    printf("3:\t%d小于0\n",n);
                    break;
                //若n的值是 -2的情况   
                case -2:
                    printf("3:\t%d小于0\n",n);
                    break;
                //其它情况 
                default:
                    printf("3:\t%d小于0\n",n);
                    break;
            }
        } 
    } 

    /*
    程序需要返回一个int类型的数据
    程序能正常终止 返回值为 0 异常终止 返回值 1 
    这里正常终止 设置为 0 
    */ 
    return 0;
} 
 
程序执行的结果：
 
 
 
 
 
说明3点：
 
 
 
变量的定义位置，C语言会将一个域中用的变量定义到所有程序指令的最前面，这里分支结构这块定义了一个n，程序能正常执行，和编译有关。 
 用C编译器的情况: gcc text.c; 
 用C++编译器的情况: g++ test.c 或者 g++ test.cpp 或者 g++ test.c (也就是用g++命令或者源文件后缀是cpp，则默认是用C++编译器)。 
 因为C++中没有这个说法，所以用g++编译不会出现问题。
switch中的break，break的作用：break语句通常用在循环语句和开关语句中。当break用于开关语句switch中时，可使程序跳出switch而执行switch以后的语句；如果没有break语句，则会从满足条件的地方（即与switch（表达式）括号中表达式匹配的case）开始执行，直到switch结构结束。
另外可以注意使用C语言中的唯一的三目运算符： 
 max = ( x > y ) ? x : y ; 
 代替了一下的代码，使用非常方便 
 if(x > y) 
 max = x; 
 else 
 max = y; 
 
 
循环结构
 
 
 
 
循环结构一般会结合着分支结构一起使用，完成对问题的求解。
 
 
循环结构程序代码：
 
//载入头文件 std 标准 io输入输出流 
#include<stdio.h>

/*
程序的入口函数 mian()函数 其中()中参数可以省略 
agrc参数表示是程序指令的个数 
agrv指针类型数组保存的是每一条指令在内存中的地址 
*/ 
int main(int agrc,char *agrv[]){

    /*
    顺序结构
    */ 
    //定义一个字符串数组 给s初始化的内容是 Hello world!
    char s[] = "Hello world!";
    //将需要输出的内容输出到console控制台 
    printf("%s\n",s);

    /*
    分支结构 
    */
    int n;
    scanf("%d",&n);
    //if分支语句 括号内部判断是不是真 若为真 执行if内的语句
    //分支语句可以没有else 但有else 一定要有一个if与之对应
    //这里的括号内部判断的是一个数字 C语言中非0的数字均为真  
    if(3)
        printf("1:\t这是一个真语句!\n") ;

    //if -else -elseif 
    //判断输入的n与0的关系并输出 
    if(n>0)
        printf("2:\t%d大于0\n",n);
    else if(n == 0)
        printf("2:\t%d等于0\n",n);
    else
        printf("2:\t%d小于0\n",n);

    //分支嵌套 switch case
    if(n>0)
        printf("3:\t%d大于0\n",n);
    else
    {
        if(n == 0)
            printf("3:\t%d等于0\n",n); 
        else{
            switch(n){
                //若n的值是 -1的情况 
                case -1:
                    printf("3:\t%d小于0\n",n);
                    break;
                //若n的值是 -2的情况   
                case -2:
                    printf("3:\t%d小于0\n",n);
                    break;
                //其它情况 
                default:
                    printf("3:\t%d小于0\n",n);
                    break;
            }
        } 
    } 
    /*
    循环结构
    */ 
    int m;
    //只要输入的内容不是文件结尾符 可以一直输入
    //循环内部可以控制结束条件 
    while(scanf("%d",&m) != EOF){
        //break
        //如果m的值等于0 后面的语句也不执行 或者写为 m==0 
        //调出while循环 执行循环外部的程序指令 
        if(!m)
            break;
        int sum = 0;
        for(int i=0;i<m;i++){
            //计算 0~m-1的和 
            sum += i;
        }
        printf("0~%d的和是%d\n",m-1,sum);
        //continue
        //如果m的值不等于0 后面的语句不执行
        //while的头入口继续循环 
        if(m!=0)
            continue;
        //执行的结果中可以发现这里从未执行 思考一下 why? 
        printf("这里执行了吗？\n");
    } 

    /*
    程序需要返回一个int类型的数据
    程序能正常终止 返回值为 0 异常终止 返回值 1 
    这里正常终止 设置为 0 
    */ 
    return 0;
} 
 
程序执行结果：
 
 
 
 
 
说明几点：
 
 
 
for循环使用最多，一般情况可以表示任何循环，和while循环均是当型循环，先判断，后执行。do{}while属于直到型循环，先做循环再判断，程序用应用不多，程序中也没有体现。
自增，自减符，++a、–a、a++、a–；符号在前表示的是：先做自增或者自减运算后以运算后的数值进行接下来的程序执行，符号在后表示的是：以当前值进行程序执行，执行结束后做自增自减运算进行下次程序执行。（在程序中可以体现）
for循环中循环语句可以是单个语句、空语句也可以是复合语句；三个表达式可以是任意类型，其中的分号”;”不能省略。
 
 
自增自减程序代码：
 
#include<stdio.h>

int main(){
    int sum = 0;
    printf("符号在后自增：%d\n",sum++);
    printf("符号在前自增：%d\n",++sum);
    return 0;
} 
 
程序运行结果： 
 
 
结语
 
 
 
 
有关C语言程序三种基本结构，顺序结构、分支结构、循环结构的主要内容和知识都已经在程序中有所体现。 
 文章内容是博主手写，难免出现错误和瑕疵，有错误请指出，有问题请积极留言一起交流。