【流程控制】

【流程控制】

流程控制

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行的结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

java中，流程控制语句有三种：顺序语句、判断（选择）语句、循环语句。

顺序语句

public class Sequence{
    public static void main(String[] args){
        System.out.println("今天天气不错");
        System.out.println("挺风和日丽的");
        System.out.println("我们下午没课");
        System.out.println("这的确挺爽的");
        //流程：开始 --> 步骤1 --> 步骤2 --> ··· -->结束
    }
}

判断语句

单if语句

• if语句的第一种格式：

if (关系表达式){
    语句体;
}

• 执行流程
  • 首先判断关系表达式，看其结果是true还是false
  • 如果是true就执行语句体
  • 如果是false就不执行语句体

public class If01{
    public static void main(String[] args){
        System.out.println("今天天气不错，正在压马路...突然发现一个快乐的地方：网吧。");
        int age = 16;
        if (age >= 18){
            System.out.println("进入网吧，开始high！");
        }
        System.out.println("回家吃饭！");
    }
}

标准if_else语句

• if语句的第二种格式：

if (关系表达式){
    语句体1;
} else{
    语句体2;
}

• 执行流程
  • 首先判断关系表达式，看其结果是true还是false
  • 如果是true就执行语句体1
  • 如果是false就执行语句体2

public class If02{
    public static void main(String[] args){
        //判断给定的数据是奇数还是偶数
        //定义变量
        int a = 1;
        if (a % 2 == 0){
            System.out.println("a是偶数");
        } else{
            System.out.println("a是奇数");
        }
        System.out.println("结束");
    }
}

复合if…else if…else语句

• if语句第三种格式：

if (条件判断1){
    语句体1;
} else if (条件判断2){
    语句体2;
}
...
}else if (条件判断n){
    语句体n;
}else{
    语句体n+1;
}

• 执行流程
  • 首先判断条件判断1，看其结果是true还是false
  • 如果是true就执行语句体1，然后结束
  • 如果是false就继续判断条件判断2，看其结果是true还是false
  • 如果是true就执行语句体2，然后结束
  • 如果是false就继续判断条件判断…，看其结果是true还是false
  • …
  • 如果条件判断n也是false，就执行语句n+1，然后结束

public class If03{
    public static void main(String[] args){
        //x 和 y 的关系满足如下：
        //如果x >= 3,那么 y =2 * x + 1
        //如果-1 < x < 3,那么 y = 2 * x
        //如果x <= -1,那么y = 2 * x -1
        int x = 10;
        int y;
        if (x >= 3){
            y =2 * x + 1;
        }else if (-1 < x && x < 3){
            y = 2 * x;
        }else{
            y = 2 * x -1;
        }
        System.out.println(y);//21
    } 
}

选择语句

switch

• switch语句格式：

switch (表达式){
    case 常量值1:
        语句体1;
        break;
	case 常量值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;  
}

• 执行流程
  • 首先计算出表达式的值
  • 其次，和case依次比较，一旦有对应的语句，在执行的过程中，遇到break就会结束
  • 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束

public class Switch01{
    public static void main(String[] args){
        int num = 1;
        //输出星期几？
        switch (num){
            case 1:
            	System.out.println("Mon");
            	break;
            	//如果省略这个break，就会向下穿透，不仅执行语句体1，还会执行语句体2，直到遇到break
            case 2:
            	System.out.println("Tue");
            	break;
            case 3:
            	System.out.println("Wed");
            	break;
            case 4:
            	System.out.println("Thur");
            	break;
            case 5:
            	System.out.println("Fri");
            	break;
            case 6:
            	System.out.println("Sat");
            	break;
            case 7:
            	System.out.println("Sun");
            	break;
            default:
            	System.out.println("输入有误");
            	break;//最后一个break语句可以省略，但是强烈推荐不要省略
        }
    }
}

注意事项：

1.多个case后面的数值不可以重复；

2.switch后面小括号当中只能是下列数据类型：

• 基本数据类型：byte/short/char/int
• 引用数据类型：String字符串、enum枚举；

3.switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略；

​ “匹配哪一个case就从哪一个位置向下执行，直到遇见了break或整体结束为止”。

循环语句

循环结构的组成部分一般可以分为四部分：

1.初始化语句，在循环开始最初执行，而且只做唯一一次；

2.条件判断：如果条件成立，则循环继续，如果不成立，则退出循环；

3.循环体：重复要做的事情内容，若干行语句；

4.步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

for循环

• for循环语句格式：

for (初始化语句①; 布尔表达式②; 步进语句④){
    循环体语句③;
}

• 执行流程
  • 执行顺序：①②③④–>②③④–>②③④–>···–>直到②不满足为止
  • ①：负责完成循环变量的初始化
  • ②：负责判断是否满足循环条件，不满足则退出循环
  • ③：具体执行的语句
  • ④：循环后，循环条件所涉及的变量的变化情况

public class For{
    public static void main(String[] args){
    	//打印十遍“我错了！”
        for (int a = 0; a < 10; a++){
            System.out.println("我错了！");
        }
        System.out.println("程序结束");
    }
}

while循环

while循环有一种标准格式，还有一种扩展格式：

标准格式：

while (条件判断){
    循环体;
}

扩展格式：

初始化语句;
while (条件判断){
    循环体;
    步进语句;
}

public class While{
    public static void main(String[] args){
    	//打印十遍“我错了！”
        int a = 0;
        while (a < 10){
            System.out.println("我错了！");
            a++;
        }
        System.out.println("程序结束");
    }
}

do-while循环

do-while循环的标准格式：

do {
    循环体;
}while (条件判断);

do-while循环的扩展格式：

初始化语句①;
do {
   循环体③;
   步进语句④;
}while (条件判断②);

• 执行流程
  • 执行顺序：①③④–>②③④–>②③④–>···–>直到②不满足为止
  • ①：负责完成循环变量的初始化
  • ②：负责判断是否满足循环条件，不满足则退出循环
  • ③：具体执行的语句
  • ④：循环后，循环条件所涉及的变量的变化情况

public class Do_While{
    public static void main(String[] args){
        int i = 1;
        do {
            System.out.println("原谅你啦！起来吧！地上怪凉！");
            i++;
        } while (i <= 10);
    }
}

####练习：求1-100之间的偶数和

public class HundredSum{
    public static void main(String[] args){
        //for循环
        int s = 0;
        for (int i = 0; i <= 100;i += 2){
            s += i;
        }
        System.out.println("1-100之间的偶数和为"+s);
        //while循环
        int s = 0;
        int i = 0;
        while(i <= 100){
            if (i % 2 == 0){
                s += i;
            }
            i++;
        }
        System.out.println("1-100之间的偶数和为"+s);
        //do-while循环
        int s = 0;
        int i = 0;
        do {
            s += i;
            i += 2;
        }while(i <= 100);
         System.out.println("1-100之间的偶数和为"+s);
    }
}

三种循环的区别

1.如果条件判断从没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次；

2.for循环的变量在小括号当中定义，只有循环内部可以是使用\。

public class LoopDifference{
    public static void main(String[] args){
        for (int i = 1; i < 0; i++){
            System.out.println("Hello");
        }
        System.out.println("----------------");
        int i = 1;
        do {
        	System.out.println("Hello"); 
        	i++;
        } while (i < 0);
    }
}

break关键字

break关键字的用法有常见的两种：

1.可以用在switch语句中，一旦执行，整个switch语句立刻结束；

2.还可以用在循环语句中，一旦执行，整个循环语句立刻结束，打断循环。

tips:

凡是次数确定的场景多用for循环，否则多用while循环。

public class

continue关键字

另一种循环控制语句是continue关键字：

一旦执行，立刻跳过当前次循环的剩余内容，马上开始下一次循环。

public class Continue{
    public static void main(String[] args){
        for (int i = 1; i <= 10; i++){
        	//跳过数字4
            if (i == 4){
                continue;
            }
            System.out.println(i);
        }
    }
}

死循环

永远停不下来的循环，叫做死循环。

死循环的标准格式：

while (true){
    循环体;
}

注意事项：

1.死循环后面的语句无法访问；

2.要让死循环有意义，达到一定条件后运行break语句，退出循环。

public class DeadLoop{
    public static void main(String[] args){
        int i = 0;
        int s = 1;
        while (true){
            i++;
            s *=i;
            if (s > 100){
                System.out.println("i! = "+ s);
                break;
            }
        }
        System.out.println("循环已退出");
    }
}

循环嵌套

**循环嵌套：**是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数 = 外循环次数 * 内循环次数。

打印九九乘法口诀表：

public class Multiplication_Table{
    public static void main(String[] args){
    	System.out.println("九九乘法口诀表");
    	System.out.println("------------------------------------------");
        for (int x = 1; x <= 9 ; x++){
            for ( int y = 1; y <= x; y++){
                System.out.print(y+"*"+x+"="+(x * y)+"	");
            }
            System.out.println("");
        }
        System.out.println("------------------------------------------");
    }
}