第二章流程控制语句

顺序语句：按照语句顺序从上往下依次执行，且每条语句必须以分号 “;” 结尾
分支语句：判断条件执行不同语句
循环语句：在满足终止循环的条件前，重复执行一条或多条语句
跳转语句：改变程序的执行顺序

顺序语句

1
2
3
4
5
6
7
8


int a = 10;
int b = 5;
int num1 = 0;
num1 = a > b ? 100 : 20;
// a>b ?    true

num1 = ((a++ + --b) > 15) && ((a = 100) > b) ? a : b;
System.out.println(num1);

分支语句

if

if ( 表达式 )｛执行语句｝

如果满足满足表达式的条件，则执行后面的语句

1
2
3
4


int a = 10;
if (a < 10) {
    System.out.println("a小于10");
}

if…else

使用else｛｝表示不满足条件的情况下执行的语句，可以添加多个else

1
2
3
4
5
6


int a = 10;
if (a < 10) {
    System.out.println("a小于10");
}else {
    System.out.println("a大于等于10");
}

if…else if…else

使用else if（）表示其他情况下执行的语句，可以添加多个else if

1
2
3
4
5
6
7
8


int a = 10;
if (a < 10) {
    System.out.println("a小于10");
} else if (a == 10) {
    System.out.println("a等于10");
} else {
    System.out.println("a大于10");
}

练习：现有分段函数 y，当 x<0 时，y=x+10，当 x=0 时，y=x/2，当 x>0 时，y=x*5，编写程序，输入x的值，输出y的值。

练习：键盘录入一个整数 x，如果 x 小于等于 100 且大于等于 0，则将 x 减 50，若结果仍大于等于 0，则输出键盘录入时 x 的值；如果 x 不在 [ 0, 100 ] 取值范围内，则输出 “ 取值范围错误 ” 。

switch

switch（表达式）｛case 1 ：…；case 2：…；case 3：…；｝

表达式一般为 byte、short、int 类型，只能与常量进行比较
每个 case 后面的值必须不同
一个 case 后面可以有多条语句，也可以没有语句
每执行完一个 case 后面的语句，程序会顺序往后执行下一条语句，需要使用 break 跳出语句
当case后的值都不匹配时，设置 default 即默认情况下执行，若无 default 则退出 switch 语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


Scanner sc = new Scanner(System.in);
System.out.print("请输入年份：");
int year = sc.nextInt();
System.out.print("请输入月份：");
int month = sc.nextInt();
int days = 0;
switch (month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        days = 31;
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        days = 30;
        break;
    case 2:
        if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
            days = 29;
        } else {
            days = 28;
        }
}
System.out.println(year + "年" + month + "月有" + days + "天");

循环语句

while

while（表达式）｛语句｝

表示如果满足表达式的条件，就执行语句，执行完后再判断是否满足条件，循环执行直到不满足条件

1
2
3
4
5


int i = 0;
while (i < 10) {
    i += 1;
}
System.out.println("跳出while循环时，i的值为：" + i);

练习：键盘录入一个整数，输出 0 到这个数的和。

练习：键盘录入三个整数，取值范围在 100~200 之间，可以等于 100 或 200，当输入的数字 不在取值范围内时，打印 “ 您输入的数字不在范围内，请重新输入 ” ，求最大值 并输出。（使用 while）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


Scanner sc = new Scanner(System.in);

//  --------------------------------------------------------

System.out.print("请输入第一个整数：");
int num1 = sc.nextInt();
while (num1 > 200 || num1 < 100) {
    System.out.print("不在取值范围内，请重新输入第一个整数：");
    num1 = sc.nextInt();
}
System.out.println("第一个数的值为：" + num1);

//  --------------------------------------------------------

System.out.print("请输入第二个整数：");
int num2 = sc.nextInt();
while (num2 > 200 || num2 < 100) {
    System.out.print("不在取值范围内，请重新输入第二个整数：");
    num2 = sc.nextInt();
}
System.out.println("第二个数的值为：" + num2);

//  --------------------------------------------------------

System.out.print("请输入第三个整数：");
int num3 = sc.nextInt();
while (num3 > 200 || num3 < 100) {
    System.out.print("不在取值范围内，请重新输入第三个整数：");
    num3 = sc.nextInt();
}
System.out.println("第三个数的值为：" + num3);

//  --------------------------------------------------------

int max = 0;
//  max = num1 > num2 ? num1 : num2;
//  max = max > num3 ? max : num3;
max = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3;
System.out.println("三个整数中最大的是：" + max);

do…while

do {语句} while (表达式)

先执行语句，再判断是否满足表达式，如果满足，则重复执行语句，否则结束循环

1
2
3
4
5


int i = 0;
do {
    i += 1;
}while (i <= 1);
System.out.println(i);

注意：do…while 循环先执行语句内容，再判断表达式是否成立，即使表达式不成立，也要先执行一次语句。

for

for（表达式1；表达式2；表达式3）｛语句｝

表达式1通常为赋值表达式，用来为循环变量赋初值如 int a = 0;
表达式2通常为关系表达式或逻辑表达式，作为循环的判断条件如 a <= 10;
表达式3通常为循环变量自增或自减表达式如 a++;

1
2
3


for (int a = 0; a < 10; a++) {
    System.out.println("现在a的值为" + a);
}

练习：键盘录入一个整数，输出0到这个数的和。

注意：for 循环的三个表达式都可以省略，但分号不能省略

如果省略表达式1

应该在for语句之前给循环变量赋初始值

如果省略表达式2

则不判断循环条件，一直执行语句，形成死循环，通常不省略

如果省略表达式3

循环变量的值不发生改变，满足条件的情况下，循环语句一直执行，与 while 循环相似

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// for循环
for (int a = 0; a < 10; a++) {
    System.out.println(a);			// 0...9
}

// for循环省略表达式3
for (int b = 0; b < 10; ) {
    System.out.println(b);			// 死循环
}

// while循环
int c = 0;
while (c < 10) {
    System.out.println(c);			// 死循环
}

跳转语句

break

终止 switch 循环语句与单层循环语句
对于多层循环语句，从内循环跳出到外循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


int sum = 0;
int count = 0;
for (int i = 1; i<=5;i++){
    for (int j = 1; j<=5;j++){
        sum += 1;				
        if (j == 3){
            break;
        }
    }
count += sum;
}
System.out.println(count);

continue

在 while 或 do…while 语句中，continue 后的语句不执行，直接开始下一次循环
在 for 语句中，continue 后的语句不执行，跳转到表达式 3，开始下一次循环

1
2
3
4
5
6
7


int sum = 0;
for (int i = 0; i < 10; i++) {
    sum += 1;
    continue;	// 跳转到 for 循环的表达式3
    sum += i;
}
System.out.println(sum);

嵌套 if 循环

1
2
3
4
5
6
7
8


int sum = 0;
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {	// 短路，跳出循环
        continue;
    }
    sum += i;
}
System.out.println(sum);

练习：键盘录入10个整数，分别计算正数个数、正数和、负数个数、负数和、零的个数（使用 continue）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


int a = 0, b = 0, c = 0, add = 0, minus = 0 , zero = 0;
System.out.println("请输入10个正整数或负整数:");
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 10; i++) {
    int num = sc.nextInt();
    if (num < 0) {
        a++;
        minus += num;
        continue;
    }else if(num == 0){
        c++;
        continue;
    }
    b++;
    add += num;
}
System.out.println("正数有"+b+"个，和为"+add);
System.out.println("负数有"+a+"个，和为"+minus);
System.out.println("零有"+c+"个");

练习

某个系统有以下11个模块：

请编写代码实现：当用户输入某个正整数时，执行该数字对应的模块（本题只要求将 “5. 计算Java工程师的月薪” 这一个模块进行具体实现，其他模块可以直接输出 “本模块功能未实现” ）。并且在每个模块执行完毕后，继续输出主界面。当用户输入 0，则退出程序。

Java工程师月薪 = 底薪 + 底薪 × 25% × 月工作完成分数 / 100 + 15 × 月实际工作天数 - 月应扣保险数；

下列程序运行的结果是（）
- A. x = 6
- B. x = 5
- C. x = 2
- D. 编译失败

1
2
3
4
5
6
7
8
9


public class Test {
    public static void main(String[] args) {
        int x = 5;
        while (++x < 4) {
            --x;
        }
        System.out.println("x=" + x);
    }
}

求出 1 ~ 300 中能被 3 整除且至少有一位数字为 5 的整数，打印输出。
键盘录入一个5位数，如果不是五位数，则重新输入。判断它是不是回文数。回文数表示：个位与万位相同，十位与千位相同，即对称的数字。
一只公鸡 5 块钱，一只母鸡 3 块钱，3 只小鸡 1 块钱，一个农夫用 100 块钱买 100 只鸡，有多少种买法？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


// 第一题
package com.company.test;

import java.util.Scanner;

public class JavaEngineer {
    public static void main(String[] args) {

        //用户选择的数
        int userSel = -1;
        //使用while(true)，在单个模块功能执行结束后，重新输出主界面，继续循环

        while (userSel < 0) {
            System.out.println("----------------------------");
            System.out.println("   蓝桥java工程师管理系统");
            System.out.println("----------------------------");
            System.out.println("1.输入Java工程师资料");
            System.out.println("2.删除指定Java工程师资料");
            System.out.println("3.查询Java工程师资料");
            System.out.println("4.修改Java工程师资料");
            System.out.println("5.计算Java工程师的月薪");
            System.out.println("6.保存新添加的工程师资料");
            System.out.println("7.对Java工程师信息排序");
            System.out.println("8.输出所有Java工程师信息");
            System.out.println("9.清空所有Java工程师数据");
            System.out.println("10.打印Java工程师数据报表");
            System.out.println("11.从文件重新导入Java工程师数据");
            System.out.println("----------------------------");

            System.out.print("请输入您的选择：");
            Scanner sc = new Scanner(System.in);
            int num = sc.nextInt();
            switch (num) {
                case 1:
                case 2:
                case 3:
                case 4:
                case 6:
                case 7:
                case 8:
                case 9:
                case 10:
                case 11:
                    System.out.println("本模块未实现");
                    break;
                    
                case 5:
                    System.out.print("请输入底薪：");
                    int salary = sc.nextInt();
                    System.out.print("请月工作完成份数：");
                    int count = sc.nextInt();
                    System.out.print("请输入月工作天数：");
                    int day = sc.nextInt();
                    System.out.print("请输入应扣保险数：");
                    int decl = sc.nextInt();
                    float total = salary + salary * 0.25f * count / 100 + 15 * day - decl;
                    System.out.println("月薪为：" + total);
                    break;

                case 0:
                    userSel = 0;
                    System.out.println("程序结束！");
            }
        }
    }
}

1
2
3
4
5
6
7
8


// 第四题
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
while (num/10000 == 0 || num/100000 != 0){
    num = sc.nextInt();
}
System.out.println(num);
// ......

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 第五题
for (int a = 0; a <= 20; a++) {
    for (int b = 0; b <= 33; b++) {
        for (int c = 0; c <= 300; c += 3) {
            if ((a * 5 + b * 3 + c / 3) == 100 && (a + b + c) == 100) {
                System.out.println("a:" + a + ",b:" + b + ",c:" + c);
            }
        }
    }
}

Random

在 JDK 自带的常用的 random 中有两个，这俩都是 产生随机数 的，不过一个是 util 下的 random，另外一个是Math下的。

util.Random

导包

1

import java.util.Random

创建Random类型的引用

1

Random ran = new Random();

使用功能

1
2
3
4
5
6
7
8


ran.nextInt() 
// 产生int返回内的随机整数

ran.nextInt(整数n) 
// 产生[0,n)范围内的int类型的随机整数

ran.nextDouble() 
// 产生[0.0,1.0)范围内double随机小数

常用的两个生成随机数的语句

1）[min,max) 随机整数 ==> ran.nextInt(max-min)+min

2）[min,max] 随机整数 ==> ran.nextInt(max-min+1)+min

—> [0,max-min+1)+min
—> [min,max+1) –> [min,max]

Math.random

Math.random() 是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值。

1
2
3
4
5


int num = (int)(Math.random()*n);			
//返回大于等于0小于n之间的随机数

int num0 = m + (int)(Matn.randon()*n);		
//返回大于等于m小于m+n（不包括m+n）之间的随机数