自学Java第三章——《流程控制语句结构》

流程控制语句结构分为：

1、顺序结构：从上到下依次执行

2、分支结构：多个分支选择其中一个分支执行

3、循环结构：重复执行某些代码

3.1 顺序结构

执行过程：从上到下顺序执行

3.1.1 输出语句

1、System.out.print(输出内容); #输出内容后不换行

2、System.out.println(输出内容); #输出内容后换行

#输出常量
System.out.print(1);
System.out.print('尚');
System.out.print(44.4);
System.out.print(true);
System.out.print("尚硅谷");
​
#输出变量
int a = 1;
char c = '尚';
double d = 44.4;
boolean b = true;
String school = "尚硅谷";
System.out.print(a);
System.out.print(c);
System.out.print(d);
System.out.print(b);
System.out.print(school);
​
#输出拼接结果
System.out.print("a = " + a);
System.out.print("c = " + c);
System.out.print("d = " + d);
System.out.print("b = " + b);
System.out.print("school = " + school);

3.1.2 输入语句

键盘输入代码的三个步骤：

1、准备Scanner类型的变量

2、提示输入xx

3、接收输入内容

示例代码：

//1、准备Scanner类型的变量
java.util.Scanner input = new java.util.Scanner(System.in);//System.in默认代表键盘输入
​
//2、提示输入xx
System.out.print("请输入一个整数：");
​
//3、接收输入内容
int num = input.nextInt();
​
//列出各种数据类型的输入
int num = input.nextInt();
long bigNum = input.nextLong();
double d = input.nextDouble();
boolean b = input.nextBoolean();
String s = input.next();
char c = input.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）
​

3.2 分支结构

分支结构：根据条件选择性的执行某些代码

分为：

1、条件判断：if...else系列

2、选择结构：switch...case系列

3.2.1 条件判断

1、单分支结构

语法格式：

if(条件表达式){
    当条件表达式成立(true)时需要执行的语句块;
}

执行过程：

条件成立，就执行{}其中的语句块，不成立就不执行。

注意：

（1）if(条件表达式)中的条件表达式的结果必须是boolean类型

（2）当{}中的语句只有一个语句（简单的语句，也可以是一个复合语句）时，可以省略{}，但是我们不建议省略

        //省略{}的情况
        if(score<0 || score>100)
            System.out.println("输入有误！");//简单的语句
        else
            //复合语句
            if(score==100){
                System.out.println("满分");
            }else if(score>=80){
                System.out.println("优秀");
            }else if(score>=60){
                System.out.println("及格");
            }else{
                System.out.println("不及格");
            }

示例代码：

int year = 2019;
int days = 28;
if(year%4==0 && year%100!=0 || year%400==0){
    days= 29;
}

2、双分支结构

语法格式：

if(条件表达式){
    当条件表达式成立(true)时需要执行的语句块1;
}else{
    当条件表达式不成立(false)时需要执行的语句块2;
}

执行过程：

当条件表达式成立(true)时执行语句块1，否则执行语句块2

注意：

（1）if(条件表达式)中的条件表达式的结果必须是boolean类型

（2）当{}中的语句只有一个语句（简单的语句，也可以是一个复合语句）时，可以省略{}，但是我们不建议

示例代码：

int num = 10;
if(num%2==0){
    System.out.println(num + "是偶数")；
}else{
     System.out.println(num + "是奇数")；
}

3、多分支结构

语法格式：

if(条件表达式1){
    当条件表达式1成立的时候，执行的语句块1；
}else if(条件表达式2){
    当条件表达式1不成立，
      条件表达式2成立的时候，执行的语句块2；
}else if(条件表达式3){
    当条件表达式1不成立，
       条件表达式2也不成立，
      条件表达式3成立的时候，执行的语句块3；
}
。。。
【else{
    当以上所有的条件表达式都不成立，需要执行的语句块n+1;
}】

执行过程：

（1）多个条件顺序往下判断，如果上面有一个条件成立了，下面的条件就不看了

（2）多个分支也只会执行其中的一个

注意：

（1）每一个条件表达式都必须是boolean值

（2）当{}中只有一个语句时，也可以省略{}，但不建议省略

（3）当多个条件是“互斥”关系（没有重叠部分），顺序可以随意；

当多个条件是“包含”关系（有重叠部分），顺序不能随意，小的在上，大的在下面

示例代码：

            int score = 78;
            if(score==100){
                System.out.println("满分");
            }else if(score>=80){
                System.out.println("优秀");
            }else if(score>=60){
                System.out.println("及格");
            }else{
                System.out.println("不及格");
            }

4、嵌套

执行过程：

当嵌套在if中，就是当外面的if成立时，才会看里面的条件判断；

当嵌套在else中，就当外面的else满足时，才会看里面的条件判断；

3.2.2 选择结构

语法格式：

switch(表达式){
    case 常量值1:
        语句块1;
        【break;】
    case 常量值2:
        语句块2;
        【break;】   
    。。。
   【default:
        语句块n+1;
        【break;】
     】
}

执行过程：

（1）入口

①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；

②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;

（2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”

（3）出口

①自然出口：遇到了switch的结束}

②中断出口：遇到了break等

注意：

（1）switch(表达式)的值的类型，只能是：4种基本数据类型（byte,short,int,char），两种引用数据类型（枚举、String）

（2）case后面必须是常量值，而且不能重复

示例代码：

int month = 4;
switch(month){
    case 3:
    case 4:
    case 5:
        System.out.println("春季");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("夏季");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("秋季");
        break;
    case 12:
    case 1:
    case 2:
        System.out.println("冬季");
        break;
    default:
        System.out.println("输入有误！");
}

3.3 循环结构

循环结构：

“重复”执行某些代码

循环结构的分类：

1、for循环

2、while循环

3、do...while循环

3.3.1 for循环

语法格式：

for(;;){
    循环体语句块；
    if(条件表达式){
        break;
    }
}
for(初始化表达式; 循环条件; 迭代表达式){
    循环体语句块；（需要重复执行的代码）
}

执行过程：

（1）初始化表达式;

（2）判断循环条件;

（3）如果循环条件成立，先执行循环体语句块；然后执行迭代表达式，再回到（2）...

（4）如果循环条件不成立，会结束for；

或者在当前循环中遇到break语句，也会结束当前for循环;

注意：

（1）for(;;)中的两个；是不能多也不能少

（2）循环条件必须是boolean类型

示例代码：

//遍历1-100之间的偶数
for(int i=1; i<=100; i++){//每次循环的步幅是1
    if(i%2==0){
        System.out.println(i);
    }
}
​
//遍历1-100之间的偶数
for(int i=2; i<=100; i+=2){//每次循环的步幅是2
    System.out.println(i);
}

3.3.2 while循环

语法格式：

while(循环条件){
    循环体语句块;
}
​
经典的形式：
while(true){
    循环体语句块;
    if(条件表达式){
        break;
    }
}

执行过程：

（1）先判断循环条件

（2）如果循环条件成立，就执行循环体语句块；然后回到（1）

（3）如果循环条件不成立，就结束while循环；

如果在循环体语句块中，遇到break，也会结束while循环；

注意：

（1）while(循环条件)中循环条件必须是boolean类型

示例代码：

//遍历1-100之间的偶数
int num = 2;
while(num<=100){
    System.out.println(num);
    num+=2;
}

3.3.3 do...while循环

语法格式：

do{
    循环体语句块;
}while(循环条件);

执行过程：

（1）先执行一次循环体语句块；

（2）判断循环条件

（3）如果循环条件成立，再次执行循环体语句块；然后回到（2）...

（4）如果循环条件不成立，就结束do...while循环；

如果在循环体语句块中，遇到break，也会结束do...while循环；

注意：

（1）while(循环条件)中循环条件必须是boolean类型

（2）do{}while();最后有一个分号

（3）do...while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

示例代码：

//从键盘输入整数，统计正数、负数的个数，输入0结束
java.util.Scanner input = new java.util.Scanner(System.in);
​
int num;
int positive = 0;
int negative = 0;
do{
    System.out.print("请输入整数（0结束）：");
    num = input.nextInt();
    
    if(num > 0){
        positive++;
    }else if(num < 0){
        negatvie++;
    }
}while(num!=0);
​
System.out.println("正数的个数：" + positive);
System.out.println("负数的个数：" + negatvie);

3.3.4 三种循环的选择

原则：三种循环之间是可以互相转换的，都能实现循环的功能

建议（习惯上）：当我们次数比较明显的时候，或者说从几循环到几的时候，一般先考虑for；

当循环体语句块至少要执行一次的时候，一般先考虑do...while；

当循环条件比较明显，但是次数不明显，循环体语句块也不是至少执行一次，那么可以考虑while结构；

三种循环结构都具有四要素：

（1）循环变量的初始化表达式

（2）循环条件

（3）循环变量的修改的迭代表达式

（4）循环体语句块

3.3.5 跳转语句

1、break

用于：

（1）switch结构

作用：结束switch结构

（2）循环结构

作用：结束当前循环

2、continue

用于：

只能用于循环结构

作用：提前结束本次循环，继续下一次循环

3、return（后面讲）