Java基础之结构-->>条件结构与循环结构

Java中程序流程控制语句包括条件结构、循环结构和跳转语句

4.1条件结构

条件结构包括顺序结构和选择结构。顺序结构在程序执行中没有跳转和判断，知道程序结束为止。选择结构包括 if 语句，if-else 语句，switch 语句，在程序执行过程中可以改变程序的执行流程。

4.1.1 if 语句

if 语句是条件判断后再处理的一种语法结构

if(条件表达式){     //条件成立后执行
  一条或多条语句   
}

//条件表达式的值只能是 boolean 类型 false / true

4.1.2 if-else 语句

if-else 语句又称为双分支选择结构

if(条件表达式){
  语句1           //当条件表达式成立，执行1
}else{
  语句2           //当条件表达式不成立，执行2
}

示例：

int num1 = 60;
int num2 = 90;
if(num1 > num2){
  System.out.println("num1大于num2");   
}else{
  System.out.println("num2大于num1");   
}

// num2大于num1

4.1.3 if-else-if 语句

if(条件表达式1){                 //如果条件表达式1成立
  语句块1                       //就执行语句块1的代码
}else if(条件表达式2){           //否则，如果条件表达式2成立
  语句块2                       //就执行语句块2的代码
}else if(条件表达式n){          //如果条件表达式n成立
  语句块n                       //就执行语句块n的代码
}
....                           //对其他条件进行判断
else{                           //如果以上所有条件都不成立
    语句块 n+1                   //就执行语句块 n+1 代码
}                    

根据学生成绩，判断属于哪个档次，并输出：

class twoday 
{
    public static void main(String[] args)  
    {
        int score = 100;
        if(score>=90){
            System.out.println("优");
        }else if(score >=80){
            System.out.println("良");
        }else if(score>=60){
            System.out.println("合格");
        }else{
            System.out.println("不合格");
        }
    }
}

// 优

4.1.4 选择语句的嵌套

选择语句的嵌套是指在 if 语句中再嵌套 if 语句

if(条件表达式1){
            if(条件表达式2){
                语句块1
            }else{
                    语句块2
                }
        }else{
            if(条件表达式3){
                语句块3
            }else{
                    语句块4
                }
        }

使用嵌套的 if 语句，根据学生成绩判断属于哪个档次

class twoday 
{
    public static void main(String[] args)  
    {
        int score = 85;
         if(score >=60){
            if(score>=80){
                if(score>=90){
                    System.out.println("优");
                }else{
                    System.out.println("良");
                }
            }else{
                System.out.println("合格");    
            }
        }else{
            System.out.println("不合格");
        }
    }
}
//良

4.1.5 switch 语句

switch 语句属于多分支结构，可以代替复杂的 if-else-if 语句，表达式的结果类型只能是 byte ,short , int ,char 类型，switch 语句是多分支的开关语句

        switch(表达式){
            case 常量表达式1 ：
                    语句组 1；
            break;
            case 常量表达式2 ：
                    语句组 2；
            break;
            case 常量表达式3 ：
                    语句组 3；
            break;
            .....
            default:
                    语句组 n；
        }

 用switch语句输出学生成绩：

class twoday 
{
    public static void main(String[] args)  
    {
        int score = 80;
        int rank = score /10;         //将100分制转换为 10分制，方便判断
        switch( rank ){
            case 10:
            case 9:
                System.out.println("优");
            break;
            case 8:
            case 7:
                System.out.println("良");
            break;
            case 6:
                System.out.println("合格");
            break;
            default:
                System.out.println("不合格");
        }
    }
}
//良

4.1.6 if 与 switch 的区别

if 语句和 switch 语句结构很相似，都是多分枝选择语句，但是switch 结构只能处理等值条件判断，而且必须是整型变量或者字符型变量，而多重 if 结构没有这个限制。使用 switch 结构时不要忘记每个 case 最后加 break ;通常情况，分支超过3层，使用 switch 语句，如果条件判断一个范围，使用 if-else-if 语句。

4.2 循环结构

循环结构一般包括 for , while , do-while 共3种循环语句

4.2.1 while 循环语句

while 循环首先判断循环条件是否满足，如果第一次循环条件不满足，直接跳出循环，循环不会执行，while 循环的特点，先判断，后执行。

while (布尔表达式) {
     语句或语句块；   
}

使用while 循环输出1~100

class twoday 
{
    public static void main(String[] args)  
    {
        int i=1;
        while(i<=100){     //循环表达式
            System.out.println(i);
            i++;    //循环变量自增1
        }
    }
}

4.2.2 do-while 循环语句

先执行 do 后面的循环体语句，然后对 while 后面的布尔表达式进行判断，如果为 true,则再次执行 do 后面的循环体，并再次对布尔表达式的值进行判读。否则结束循环体，do-while 特点是条件表达式无论是否成立，都至少会执行一次。

do{
   语句或语句块   
}while(布尔表达式);

通过 do-while 输出1~100

class twoday 
{
    public static void main(String[] args)  
    {
        int i=1;
        do{
            System.out.println(i);    //do 先执行一次输出
            i++;
        }while(i<=100);
    }
}

4.2.3 while 与 do-while 的区别

while 语句是先判断后执行，do-while 是先执行后判断，（如果条件表达式不成立，while不会执行。do-while 语句至少会执行一次）。

4.2.4 for循环语句

for(初始化表达式；条件表达式；迭代语句){
    循环体语句；
}

初始化表达式只在循环前执行一次，通常作为迭代变量的定义。条件表达式是一个布尔表达式，当值为 true 时，才会继续执行 for 语句的循环体语句，迭代表达式用于改变循环条件的语句，如自增，自减等运算。

for循环语句的执行过程：

①执行初始化表达式

②对中间的条件表达式值进行判断，如果为 true，则继续执行后面的循环体语句

③执行迭代表达式，改变循环变量的值

④重复执行上述两步，开始下一次循环，直到某次中间的条件表达式为 false，结束整个循环语句

用for 循环输出 1~100

class twoday 
{
    public static void main(String[] args)  
    {
        for(int i=0;i<=100;i++){    //定义循环变量，循环语句，初始化值为 0 ；
            System.out.println(i);
        }
    }
}

注：即使表达式为空，分隔3个表达式的分号“；”也不能省略。

for(;;;){

}

//合法的，正确的

4.2.5 嵌套循环语句

①while 语句嵌套

while(条件表达式1){
    while(条件表达式2){
    .....
        }
}            

②do-while 语句嵌套

        do{
            do{
                ...
            }while(条件表达式1)；
        }while(条件表达式2)；

③for语句与while循环嵌套

for(;;){
    while(条件表达式){...}
}

④for语句嵌套

for(;;){
    for(;;){...}
}

⑤for 循环与 do-while循环嵌套

for(;;){
    do{...}while(条件表达式)；
}

⑥while循环与for循环嵌套

while(条件表达式){
    for(;;){...}
}

⑦do-while循环与for循环嵌套

do{
    for(;;){...}
}while(条件表达式)；

⑧do-while循环与while循环嵌套

do{
    while(条件表达式1){...}
}while(条件表达式2);

⑨while循环与do-while循环嵌套

while(条件表达式1){
    do{...}while(条件表达式2);
}

使用嵌套循环用“*”输出直角三角形

class twoday 
{
    public static void main(String[] args)  
    {
        int i, j;
        for(i=0;i<6;i++){      //第一重循环控制行数
            for(j=0;j<i;j++){          //第二重循环控制*数量
                System.out.print("*");   //输出*
            }
            System.out.println();     //换行
        }
    }
}
/*
*
**
***
****
*****
*/

4.3 跳转语句

跳转语句有 break,continue和return

4.3.1 break 跳转语句

当循环结构中执行到 break 语句时，它立即停止当前循环并执行循环下面的语句

在循环结构中使用 break 输出0~99

class twoday 
{
    public static void main(String[] args)  
    {
        int i;
        for(i=1;i<101;i++){
            if(i==100){
                break;       //当i=100时停止循环
                }
            System.out.println(i);
        }
    }
}
// 1 2 3 4 5 ...99

当i=100时，执行break语句，终止循环，在一个循环中可以有多个break语句，break不是专门用来终止循环的，只有在某些情况下来取消一个循环。

4.3.2 continue 跳转语句

continue 是跳过本次循环，执行下一次循环语句

class twoday 
{
    public static void main(String[] args)  
    {
        int i;
        for(i=1;i<101;i++){
            if(i==3){               //当i=3时，跳过本次循环，继续执行后面
                continue;
                }
            System.out.println(i);
        }
    }
}
// 1 2  4 5 ...99

4.3.3 break和continue的区别

continue 语句只结束本次循环，而不是终止整个循环的执行。而break 语句则是结束整个循环过程，不再判断执行循环的条件是否成立。

4.3.4 return 跳转语句

return 语句是终止当前方法运行，返回到调用该方法的语句处，该语句还提供相应返回值

if(x>=0){
            return true;
        }
        return false;
    }

当 if 条件语句结果为true 时，执行第一条 return 语句，退出方法。下面（return false）跳过不执行

 非常感谢<从零开始学Java>一书对我的帮助，本文借鉴于此，仅用来学习，回顾，巩固。再次感谢。