java程序控制语句实验报告 java程序控制结构

文章目录

• 1、程序控制结构

• 1.1、定义
• 1.2、分类

• 2、顺序控制

• 2.1、分支控制 if-else

• 2.1.1、单分支
• 2.1.2、双分支
• 2.1.3、多分支
• 2.1.4、嵌套分支
• 2.1.5、switch 分支结构
• 2.1.6、switch 和 if 的比较

• 3、循环控制

• 3.1、for 循环控制

• 3.1.1、注意事项和细节说明

• 3.2、while 循环控制

• 3.2.1、注意事项和细节说明

• 3.3、do..while 循环控制

• 3.3.1、注意事项和细节说明

• 3.4、多重循环控制

• 3.4.1、注意事项和细节说明

• 4、跳转控制语句

• 4.1、跳转控制语句-break
• 4.2、跳转控制语句-continue
• 4.3、跳转控制语句-return

1、程序控制结构

1.1、定义

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

1.2、分类

1. 顺序控制
2. 分支控制
3. 循环控制

2、顺序控制

2.1、分支控制 if-else

让程序有选择的的执行,分支控制有三种

1. 单分支 if
2. 双分支 if-else
3. 多分支 if-else if -…-else

2.1.1、单分支

public static void main(String[] args) {
    int age = 20;
    if (age > 18) {
        System.out.println("用户超过18岁");
    }
}

2.1.2、双分支

public static void main(String[] args) {
    int age = 10;
    if (age > 18) {
        System.out.println("用户超过18岁");
    } else {
        System.out.println("用户小于18岁");
    }
}

2.1.3、多分支

int n = 200;
if (n == 100) {
    System.out.println("n == 100");
} else if (n == 200) {
    System.out.println("n == 200");
} else {
    System.out.println("===");
}

2.1.4、嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。
建议：不要超过3层，可读性不好。

public static void main(String[] args) {

    // 参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰,
    // 并且根据性别提示进入男子组或女子组, 输入成绩和性别，进行判断和输出信息
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入分数");
    double score = scanner.nextDouble();
    System.out.println("请输入性别");
    char gender = scanner.next().charAt(0);
    if (score > 8.0) {
        if (gender == '男') {
            System.out.println("恭喜您进入男子组...分数是" + score);
        } else if (gender == '女') {
            System.out.println("恭喜您进入女子组...分数是" + score);
        } else {
            System.out.println("您的性别输入有误...");
        }
    } else {
        System.out.println("您被淘汰了...");
    }

2.1.5、switch 分支结构

public static void main(String[] args) {
    // 编写一个程序，该程序可以接收一个字符，比如:a,b,c
    char n = 'c';
    switch (n) {
        case 'a':
            System.out.println('a');
            break;
        case 'b':
            System.out.println('b');
            break;
        case 'c':
            System.out.println('c');
            break;
        default:
            System.out.println("不存在的字符");
    }
}

2.1.6、switch 和 if 的比较

1. 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。
2. 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广

3、循环控制

3.1、for 循环控制

就是让你的代码可以循环的执行

说明

1. for 关键字，表示循环控制
2. for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
3. 循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
4. 如果 循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略

3.1.1、注意事项和细节说明

1. 循环条件是返回一个布尔值的表达式 。
2. for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代 语句，中间用逗号隔开。

public static void main(String[] args) {
    // 打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和
    int count = 0;
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        if (i % 9 == 0) {
            System.out.println(i);
            sum += i;
            count++;
        }
    }
    System.out.println("1~100之间9的倍数，个数是" + count + "个，总和是" + sum);
}

// 打印出如下效果:
// 0 + 5 = 5
// 1 + 4 = 5
// 2 + 3 = 5
// 3 + 2 = 5
// 4 + 1 = 5
// 5 + 0 = 5

public static void main(String[] args) {
    for (int i = 0; i <= 5; i++) {
        System.out.println(i + " + " + (5 - i) + " = " + 5);
    }
}

3.2、while 循环控制

3.2.1、注意事项和细节说明

1. 循环条件是返回一个布尔值的表达式
2. while 循环是先判断再执行语句

public static void main(String[] args) {
    // 打印 40—200 之间所有的偶数
    int i = 40;
    while (i <= 200) {
        if (i % 2 == 0) {
            System.out.println(i);
        }
        i++;
    }
}

3.3、do…while 循环控制

循环变量初始化; 
do	{ 
	循环体(语句); 
	循环变量迭代; 
} while(循环条件);

1. do while 是关键字
2. 也有循环四要素, 只是位置不一样
3. 先执行，再判断，也就是说，一定会至少执行一次
4. 最后有一个 分号

3.3.1、注意事项和细节说明

1. 循环条件是返回一个布尔值的表达式
2. do…while 循环是先执行，再判断， 因此它至少执行一次

public static void main(String[] args) {
    // 统计 1---200 之间能被 5 整除但不能被 3 整除的个数
    int count = 0;
    int i = 1;
    do {
        if (i % 5 == 0 && i % 3 != 0) {
            System.out.println(i);
            count++;
        }
        i++;
    } while (i <= 200);
    System.out.println("1---200之间能被5整除但不能被3整除的个数是" + count);
}

3.4、多重循环控制

3.4.1、注意事项和细节说明

1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。 【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
3. 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

public static void main(String[] args) {
    // 1) 统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
    // 2) 统计三个班及格人数，每个班有 5 名同学。
    double totalScore = 0;
    int totalPassCount = 0;
    Scanner scanner = new Scanner(System.in);
    for (int i = 1; i <= 3; i++) {
        double totalClassScore = 0;
        int passCount = 0;
        for (int j = 1; j <= 5; j++) {
            System.out.print("第[" + i + "]个班的学生,请输入分数: ");
            double score = scanner.nextDouble();
            if (score >= 60) passCount++;
            System.out.println("第" + i + "个班的第" + j + "个学生的成绩是" + score);
            totalClassScore += score;
        }
        totalScore += totalClassScore;
        totalPassCount += passCount;
        System.out.println("第" + i + "个班的平均分是" + (double)(totalClassScore / 5));
        System.out.println("第" + i + "个班及格的人数是" + passCount);
    }
    System.out.println("所有班级的平均分是" + (double)(totalScore / (5 * 3)));
    System.out.println("所有班级及格的人数是" + totalPassCount);
}

public static void main(String[] args) {
	// 打印空心金字塔
    //    *
    //   * *
    //  *   *
    // *     *
    //*********
    int totalLevel = 5;
    for (int i = 1; i <= totalLevel; i++) {
        for (int z = 0; z < totalLevel - i; z++) {
            System.out.print(" ");
        }
        for (int j = 1; j <= 2 * i - 1; j++) {
            if (j == 1 || j == 2 * i - 1 || i == totalLevel) {
                System.out.print("*");
            } else {
                System.out.print(" ");
            }
        }
        System.out.println();
    }
}

4、跳转控制语句

4.1、跳转控制语句-break

break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环 [for , while , do-while] 中。

public static void main(String[] args) {
    // 随机生成 1-100 的一个数，直到生成了 97 这个数，看看你一共用了几次
    int count = 0;
    while (true) {
        count++;
        if ((int) ((Math.random() * 100) + 1) == 97) {
            break;
        }
    }
    System.out.println("一共用了" + count + "次");
}

4.2、跳转控制语句-continue

1. continue 语句用于结束本次循环，继续执行下一次循环。
2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的 使用的规则一样。

public static void main(String[] args) {
    // 打印1-10，跳过8
    for (int i = 1; i < 11; i++) {
        if (i == 8) continue;
        System.out.println(i);
    }
}

4.3、跳转控制语句-return

return 使用在方法，表示跳出所在的方法。注意：如果 return 写在 main 方法，退出程序

public static void main(String[] args) {
    // 1-10，只打印1-3
    for (int i = 1; i < 11; i++) {
        if (i > 3) {
            return;
        }
        System.out.println(i);
    }
}