Java的流程控制

2023-03-26 本文已影响0人笔头还没烂

流程控制语句：顺序、选择、循环

顺序结构

特点：代码从上到下依次执行

示例代码如下：

public class CharDemo {
    public static void main(String[] args) {
        //定义一个变量存放字符'a'
        char a = 'a';
        System.out.println("a = " + a);
        char ch = 65535;
        //char类型定义的数据范围是0～65535，当值超出这个范围，则需做类型的强制转换，否则会报错。
        char ch1= (char) 65536;
        System.out.println("ch=" + ch);
        char c = '\u005d';
        System.out.println("c="+c);
    }
}

选择结构：

特点：根据条件执行对应的内容。

if 结构，if-else结构
判断条件是布尔类型

判断条件是一个范围

格式
```
if(条件){
   <语句>
}

if(条件){
   <语句1>
}else {
   <语句2>
}
```
当 if(条件) 或 else 后只跟一条语句时，可以把包裹该语句的大括号省略掉。（但是建议加上大括号，增强代码的可读性。）

多重if

//案例演示：
/*
需求描述：
编写一个程序，根据考试成绩，输出相应的评定信息。
成绩大于等于90分，输出“优”
成绩大于等于80分且小于90分，输出“良”
成绩大于等于60分小于80分，输出“中”
成绩小于60分，输出“不及格”
*/
public class ScoreAssess {
    public static void main(String[] args) {
        /*
        需求描述：
        编写一个程序，根据考试成绩，输出相应的评定信息。
        成绩大于等于90分，输出“优”
        成绩大于等于80分且小于90分，输出“良”
        成绩大于等于60分小于80分，输出“中”
        成绩小于60分，输出“不及格”
        */

        System.out.print("请输入学生成绩：");
        Scanner scanner = new Scanner(System.in);
        float score = scanner.nextFloat();
        if (score >= 90) {
            System.out.println("优");
        }
        if (score >= 80 && score < 90) {
            System.out.println("良");
        }
        if (score >= 60 && score < 80) {
            System.out.println("中");
        }
        if (score < 60) {
            System.out.println("不及格");
        }
    }
}

运行结果如下：

请输入学生成绩：59
不及格

if-else 结构

格式：

if(条件1){
   <语句1>
}else if(条件2){
   <语句2>
}else if(条件3){
   <语句3>
}
...
else {
   <语句n>
}

也可用 if -else 结构改写上面的案例代码

public class ScoreAssess {
    public static void main(String[] args) {
        /*
        需求描述：
        编写一个程序，根据考试成绩，输出相应的评定信息。
        成绩大于等于90分，输出“优”
        成绩大于等于80分且小于90分，输出“良”
        成绩大于等于60分小于80分，输出“中”
        成绩小于60分，输出“不及格”
        */

        System.out.print("请输入学生成绩：");
        Scanner scanner = new Scanner(System.in);
        float score = scanner.nextFloat();
        if (score >= 90) {
            System.out.println("优");
        }else if (score >= 80) {
            System.out.println("良");
        }else if (score >= 60) {
            System.out.println("中");
        }else {
            System.out.println("不及格");
        }
    }
}

else if(条件) 后面跟的语句，相当于对它上面 if(条件) 跟的语句 进行取反；即 else if (score >= 80) 相当于 score >= 80 && score < 90 。

嵌套if

将整个 if 块插入另一个 if 块中

格式：

if(表达式1){
  <语句1>
  if(表达式2){
    <语句1>
    if(表达式3){
       <语句1>;
       ...
    }else{
       <语句2>
    }
  }else{
    <语句2>
  }
}else {
  <语句2>
}

案例：

//从键盘输入两个整数，经过判断输出他们的关系（大于、小于，等于）
public class IntCompare {
    public static void main(String[] args) {
        //从键盘输入两个整数，经过判断输出他们的关系（大于、小于，等于）
        System.out.print("请输入第一个整数：");
        Scanner scanner = new Scanner(System.in);
        int num1 = scanner.nextInt();
        System.out.print("请输入第二个整数：");
        int num2 = scanner.nextInt();
        if (num1 != num2){
            if (num1 > num2) {
                System.out.println(num1+"大于"+num2);
            }else {
                System.out.println(num1+"小于"+num2);
            }
        }else {
            System.out.println(num1+"和"+num2+"相等");
        }
    }
}

switch结构

判断条件是常量值

格式

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

执行流程
- 先计算出 switch 表达式的值，再将该值与后面的 case 常量表达式的值逐一匹配。如果某个 case 语句常量表达式的值与switch表达式的值相等，则会执行该 case 表达式后面的语句。
- 如果执行过程中遇到 break 语句，就会跳出这个 switch 结构，switch 结构终止执行。
- break 不是必须的，是可以省略的。
- default 语句：前面的 case 语句都不满足的情况下，才会执行 default 语句。default 不是必须的，是可以没有的。当 switch 表达式的值与 case 常量表达式的值都不匹配，当没有default语句时，则 switch 结构将终止执行。
- JDK 7.0 以后 switch表达式的值可以是基本数据类型的 byte,short,int,char，以及 String 类型。

案例1:

public class WeekDemo1 {
    public static void main(String[] args) {
        /*
            从键盘输入1-7之间的任意数字，分别输出对应的信息
            1——星期一
            2——星期二
            3——星期三
            4——星期四
            5——星期五
            6——星期六
            7——星期日
         */
        System.out.print("请输入1-7之间的任意数字：");
        Scanner scanner = new Scanner(System.in);
        int week = scanner.nextInt();
        switch(week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("该数字超出了1-7的范围");
        }
    }
}

运行结果如下：

请输入1-7之间的任意数字：7

星期日

验证：switch表达式的值可以是字符串。

案例2:

import java.util.Scanner;

public class WeekDemo2 {
    public static void main(String[] args) {
        /*
            从键盘输入1-7之间的任意单词，分别输出对应的信息
            Monday——星期一
            Tuesday——星期二
            Wednesday——星期三
            Thursday——星期四
            Friday——星期五
            Saturday——星期六
            Sunday——星期日
         */
        System.out.print("从键盘输入1-7之间的任意单词：");
        Scanner scanner = new Scanner(System.in);
        String week = scanner.next();
        week = week.toUpperCase();//将字符串中的字符全部转成大写
        switch (week) {
            case "MONDAY":
                System.out.println("星期一");
                break;
            case "TUESDAY":
                System.out.println("星期二");
                break;
            case "WEDNESDAY":
                System.out.println("星期三");
                break;
            case "THURSDAY":
                System.out.println("星期四");
                break;
            case "FRIDAY":
                System.out.println("星期五");
                break;
            case "SATURDAY":
                System.out.println("星期六");
                break;
            case "SUNDAY":
                System.out.println("星期日");
                break;
            default:
                System.out.println("输入的单词有误！");
        }
    }
}

运行结果如下：

从键盘输入1-7之间的任意单词：Sunday
星期日

循环结构：

使用场景：
- 问题一：反复输入数字，判断输出对应是星期几；
- 问题二：求1到100的累加和；

特点：循环执行某一部分代码。

while

语法格式：

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

案例1：将小于5的正整数打印输出

int n = 1;
while(n<5) {
   //输出n的值
   n++;
}

ps:

n的值必须先进行初始化；
循环变量n的值必须被改变；

执行流程：

首先判断循环条件是否成立，成立则执行循环体的语句；当不成立的时候，则跳出循环体，程序终止执行。

案例2:

求1到5的累加和

public class PlusDemo {
    public static void main(String[] args) {
        //求1到5的累加和
        int sum = 0;
        int num = 1;
        while (num <= 5) {
            sum = num + sum;
            num++;
        }
        System.out.println("1到5的累加和是"+sum);
    }
}

运行结果如下：

1到5的累加和是15

案例3:

循环输出26个英文字母，分两行输出

public class CharDemo {
    public static void main(String[] args) {
        //循环输出26个英文字母，分两行输出
        char c = 'A';
        char finalChar = 'Z';
        while (c <= finalChar) {
            if (c == 'O'){
                System.out.println();
            }
            if (c == 'U') {
                System.out.print("    ");
            }
            System.out.print(c+" ");
            c = (char) (c + 1);
        }
    }
}

运行结果如下：

A B C D E F G H I J K L M N
O P Q R S T U V W X Y Z

do-while

语法格式：

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

注意事项：
do-while循环至少执行一次；
循环条件后的分号不能丢；

案例1：

//输出小于5的所有正整数
int n = 1;
do {
   //输出n的值
   n++;
}while(n<5);

案例2:

//求1到5的累加和
public class DoWhileDemo {
    public static void main(String[] args) {
        //求1到5的累加和
        int sum = 0;
        int num = 1;
        do {
            sum = num + sum;
            num++;
        }while(num <= 5);
        System.out.println("1到5的累加和是"+sum);
    }
}

输出结果如下：

1到5的累加和是15

案例3: 猜字游戏。要求猜一个介于1到10之间的数字。然后将猜测的值与实际值进行比较，并给出提示，以便能更接近实际值，直到猜中为止。

public class DoWhileDemo2 {
    public static void main(String[] args) {
        //案例3: 猜字游戏。要求猜一个介于1到10之间的数字。然后将猜测的值与实际值进行比较，并给出提示，以便能更接近实际值，直到猜中为止。
        int result = (int) (Math.random() * 10 + 1);//使用随机数生成1到10之间的整数
        System.out.println("请求一个介于1到10之间的数字：");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        do{
            if (num < result) {
                System.out.println("猜小了，请继续");
                num = sc.nextInt();
            }else {
                System.out.println("猜大了，请继续");
                num = sc.nextInt();
            }
        }while (num != result);
        System.out.println("恭喜你猜对了!");
    }
}

运行结果如下：

请求一个介于1到10之间的数字：
5
猜小了，请继续
8
猜大了，请继续
7
猜大了，请继续
6
恭喜你猜对了!

for

语法格式：

for(表达式1;表达式2;表达式3){
   语句
}

执行流程：

表达式1对应的是对循环变量定义并初始化的语句；
表达式2对应的是循环条件的表达式；
表达式3对应的是对循环变量进行改变的表达式。

案例1：输出小于5的所有正整数。

for(int i=1;i<=5;i++){
   //输出语句
}

ps：分号不可省略，用于分隔三个表达式的内容

案例2:使用 for 循环，求1到5的累加和。

public class ForDemo {
    public static void main(String[] args) {
        //用for循环求1到5的累加和
        int sum = 0;
        for (int i=1;i<=5;i++){
            sum = sum + i;
        }
        System.out.println("1到5的累加和是"+sum);
    }
}

运行结果如下：

1到5的累加和是15

上面的代码可以改写成：

public class ForDemo {
    public static void main(String[] args) {
        //用for循环求1到5的累加和
        int i=1;
        int sum = 0;
        for (;;){
            sum = sum + i;
            i++;
            if(i>5) break;
        }
        System.out.println("1到5的累加和是"+sum);
    }
}

案例2:

public class NumberInput {
    public static void main(String[] args) {
        //循环输入数字1-10，如果输入0则跳出循环
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.print("请输入1-10的数字：");
            int input = sc.nextInt();
            if (input == 0) {
                System.out.println("您输入了数字0，程序退出");
                break;
            }
            System.out.println("您输入的数字是"+input);
        }
    }
}

运行结果如下：

请输入1-10的数字：8
您输入的数字是8
请输入1-10的数字：7
您输入的数字是7
请输入1-10的数字：3
您输入的数字是3
请输入1-10的数字：0
您输入了数字0，程序退出

循环嵌套

例1：求1! + 2! + 3! + ... + 10!

public class JieChenDemo {
    public static void main(String[] args) {
        //求1! + 2! + 3! + ... + 10!
        int sum = 0;
        for (int i=1; i<=10; i++){
            int temp = i;
            int res = 1;
            while (temp > 0){
                System.out.print(temp+" ");
                res = temp * res;
                temp--;
            }
            System.out.println(temp+"的阶乘是"+res);
            sum = sum + res;
        }
        System.out.println("1到10的阶乘结果是"+sum);
    }
}

运行结果如下：

1 0的阶乘是1
2 1 0的阶乘是2
3 2 1 0的阶乘是6
4 3 2 1 0的阶乘是24
5 4 3 2 1 0的阶乘是120
6 5 4 3 2 1 0的阶乘是720
7 6 5 4 3 2 1 0的阶乘是5040
8 7 6 5 4 3 2 1 0的阶乘是40320
9 8 7 6 5 4 3 2 1 0的阶乘是362880
10 9 8 7 6 5 4 3 2 1 0的阶乘是3628800
1到10的阶乘结果是4037913

例2:使用嵌套 while 循环输出10行10列的星号

public class StartDemo1 {
    public static void main(String[] args) {
        //使用嵌套 while 循环输出10行10列的星号
        int i = 1;
        while (i <= 10) {
            int k = 1;
            while (k <= 10) {
                System.out.print("* ");
                k++;
            }
            System.out.print("\n");
            i++;
        }
    }
}

运行结果如下：

13while嵌套循环案例2输出.png

break语句和continue语句
- break语句
  - 作用：
    - 结束当前循环的执行
    - 执行完break语句后，循环体中位于break语句后面的语句就不会被执行
    - 在多重循环中，break语句只向外跳一层
- continue语句
  - 作用：
    - continue语句只能用在循环里
    - continue语句可以结束当前循环的执行，但是要继续下一次循环的执行。

Java的流程控制

猜你喜欢

热点阅读