梧席
Java流程控制语句
Q7nl1s admin
  2022-07-14 21:48:02 2022-07-14 21:48   2022-07-14 21:48:02      3.5k Words  

Java流程控制语句

Java语句

Java语句编写方式包含分行编写和单行编写两种，如下。

1
2
3
4
5
6
//多行编写
String str = "Apple "
+"Banner "+"Pear "
+" Orange";
//单行编写
int a=0,b,c;b=a+10;b++;c=a*b;System.out.println(c);

空语句：在程序中什么都不做，其实就是一个分号，如下。

1
; // 其实就是一个分号

表达式语句：存在有意义表达式语句和无意义表达式语句，下面举例有意义表达式语句。

1
2
3
4
5
pi = 3.1415926;
output(pi); // 将pi的值传递到output()函数中作为参数
sum = (a+b)/2;
printf("%f",sum); // 将sum的值传递到printf()函数输出
temp = x*y*z-y+(20-x); // 将表达式的值保存到temp变量中

复合语句：由一个大括号和其内可选的statement-list组成，如下。

1
2
3
{
    statement-list // 语句列表
}

Java if-else

Java的if-else语句与C/C++没有不同的地方，应用案例如下。

活动计划安排，如果今天是工作日，去上班；如果今天是周末，则出去游玩；同时，如果周末天气晴朗，去室外游乐场游玩，否则去室内游乐场游玩。实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) {
    String today = "周末";
    String weather = "晴朗";
    if (today.equals("周末")) {
        if (weather.equals("晴朗")) {
            System.out.println("去室外游乐场游玩");
        } else {
            System.out.println("去室内游乐场游玩");
        }
    } else {
        System.out.println("去上班");
    }
}

Java switch case

switch case语句是由四部分组成：

  • switch：后接括号表达式，表达式必须为byte，short，int，char，string类型。Java7 增强了 switch 语句的功能，允许 switch 语句的控制表达式是 java.lang.String 类型的变量或表达式。（ 在C++中为char、short、int、long、bool、enum）。
  • case：类型为 char、byte、 short 或 int 的常量表达式。或者枚举常量。从 Java SE 7 开始， case 标签还可以是字符串字面量。如下。
1
2
3
4
5
6
String input = ...;
switch (input.toLowerCase()) {  // toLowerCase用于将大写字符转换为小写
    case "yes":
        ...
        break;
}
1
2
3
4
5
6
7
Size sz = ...;
switch (sz) {
    case SMALL: // no need to use Size.SMALL
        ...
        break;
    ...
}

注意：重复的 case 值是不允许的。

  • default：default 块和 case 块的先后顺序可以变动，不会影响程序执行结果。
  • break：即跳出当前结构。

if语句和switch语句的区别：

  1. 使用效率：witch 语句高于 if 语句，在分支数众多的情况下很明显。
  2. 实用性：switch 语句不如 if 条件语句，if应用最广泛并且最实用。
  3. 何时使用if语句和switch语句：一般情况下，对于判断条件较少的，可以使用 if 条件语句，但是在实现一些多条件的判断中，最好使用 switch 语句

-

Java项目实战：实现淡旺季飞机票打折（switch case版）

某航空公司为吸引更多的顾客推出了优惠活动。原来的飞机票价为 3000 元，活动时，411 月旺季，头等舱 9 折，经济舱 8 折；13 月、12 月淡季，头等舱 5 折，经济舱 4 折，求机票的价格。

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
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入出行的月份：");
    int month = sc.nextInt();
    System.out.println("选择头等舱还是经济舱？数字1为头等舱，数字2为经济舱");
    int kind = sc.nextInt();
    double result = 60000; // 原始价格
    switch (month) {
    // 旺季的票价计算
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
        switch (kind) {
        case 1: // 旺季头等舱
            result = result * 0.9;
            break;
        case 2:
            result = result * 0.8;
            break;
        default:
            System.out.println("选择种类有误，请重新输入！");
            break;
        }
        break;
    case 1:
    case 2:
    case 3:
    case 12:
        switch (kind) {
        case 1: // 旺季头等舱
            result = result * 0.5;
            break;
        case 2:
            result = result * 0.4;
            break;
        default:
            System.out.println("选择种类有误，请重新输入！");
            break;
        }
        break;
    default:
        System.out.println("日期选择有误，请重新输入！");
        break;
    }
    System.out.println("您选择的机票价格为：" + result);
}

Java项目实战：根据出生日期计算（判断）星座（switch case版）

十二星座对应的日期划分范围如下：

1
2
3
4
5
6
白羊：0321~0420          天秤：0924~1023
金牛：0421~0521          天蝎：1024~1122
双子：0522~0621          射手：1123~1221
巨蟹：0622~0722          摩羯：1222~0120
狮子：0723~0823          水瓶：0121~0219
处女：0824~0923          双鱼：0220~0320

实现代码：

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
public static void main(String[] args) {
    System.out.println("请输入您的出生年月（如 0123 表示 1 月 23 日）：");
    Scanner sc = new Scanner(System.in);
    int monthday = sc.nextInt();
    int month = monthday/100;
    int day = monthday%100;
    String xingzuo = "";
    switch (month) {
　　    case 1:
            xingzuo = day<21?"摩羯座":"水瓶座";
            break;
　　    case 2:
            xingzuo = day<20? "水瓶座":"双鱼座";
            break;
　　    case 3:
            xingzuo = day<21?"双鱼座":"白羊座";
            break;
　　    case 4:
            xingzuo = day<21?"白羊座":"金牛座";
            break;
        case 5:
            xingzuo = day<22?"金牛座":"双子座";
            break;
　　    case 6:
            xingzuo = day<22?"双子座":"巨蟹座";
            break;
　　    case 7:
            xingzuo = day<23?"巨蟹座":"狮子座";
            break;
　　    case 8:
            xingzuo = day<24?"狮子座":"处女座";
            break;
　　    case 9:
            xingzuo = day<24?"处女座":"天秤座";
            break;
　　    case 10:
            xingzuo = day<24?"天秤座":"天蝎座";
            break;
　　    case 11:
            xingzuo = day<23?"天蝎座":"射手座";
            break;
　　    case 12:
            xingzuo = day<22?"射手座":"摩羯座";
            break;
    }
    System.out.println("您的星座是：" +xingzuo);
}

Java while

Java的while语句与C/C++并无区别，唯一要注意的是while和do-while的区别。

while 循环和 do-while 循环的不同处如下：

  • 语法不同：与 while 循环相比，do-while 循环将 while 关键字和循环条件放在后面，而且前面多了 do 关键字，后面多了一个分号。
  • 执行次序不同：while 循环先判断，再执行。do-while 循环先执行，再判断。
  • 一开始循环条件就不满足的情况下，while 循环一次都不会执行，do-while 循环则不管什么情况下都至少执行一次。

Java for

语法格式如下：

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

与C/C++无区别，不赘述。唯一要注意的是for语句的三种情况：

  1. 条件表达式1为空
  2. 条件表达式2为空
  3. 条件表达式3为空
名称 概念 适用场景 特点
for 根据循环次数限制做多少次重复操作 适合循环次数是已知的操作 初始化的条件可以使用局部变量和外部变量使用局部变量时，控制执行在 for 结束后会自动释放，提高内存使用效率。且变量在 for 循环结束后，不能被访问。先判断，再执行
while 当满足什么条件的时候，才做某种操作 适合循环次数是未知的操作 初始化的条件只能使用外部变量，且变量在 while 循环结束后可以访问先判断，再执行
do-while 先执行一次，在判断是否满足条件 适合至少执行一次的循环操作 在先需要执行一次的情况下，代码更加简洁。先执行一次，再判断

表3-1 for、do-while和while的区别

Java foreach

语法格式如下：

1
2
3
for(类型 变量名:集合) {
    语句块;
}

其中“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。

举个例子，用foreach语句遍历一个int类型的数组：

1
2
3
4
5
6
7
// 声明并初始化int数组
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for each----");
// for-each语句
for (int item : numbers) {
    System.out.println("Count is:" + item);
}

foreach 循环无须循环条件，无须循环迭代语句，这些部分都由系统来完成，它自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach 循环自动结束。

foreach语句对字符串数组同样适用，假设在一个字符串数组中存储了几种编程语言，现在将这些编程语言遍历输出。

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    String[] languages={"Java","ASP.NET","Python","C#","PHP"};
    System.out.println("现在流行的编程语言有：");

    // 使用 foreach 循环语句遍历数组
    for(String lang:languages) {
        System.out.println(lang);
    }
}

Java return

语法格式：

1
return 与方法相同类型的变量;

不多说了。

Java break

Java的break语句包含了两种，一种带标签，一种不带标签。

不带标签的break：跳出当前的一层循环。

带标签的break：跳出指定标签位置处的那一层循环。

实验带标签的break语句可以实现goto的功能，可以将其用来处理推出嵌套很深的循环。

标签 break 语句的通用格式如下：

1
break label;

label 是标识代码块的标签，用标签（label）可以指定一个代码块，标签可以是任何合法有效的 Java 标识符，后跟一个冒号。下面是实验带标签break语句的示例：

1
2
3
4
5
6
7
8
9
10
11
12
public class GotoDemo {
    public static void main(String[] args) {
        label: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.println(j);
                if (j % 2 != 0) {
                    break label;
                }
            }
        }
    }
}

运行结果：

1
2
0
1

可见break跳出的循环时label指定的那一层，需要注意的是在 break 所在循环的外层循环之前定义label才有意义。

Java continue

continue 的作用是中止当前迭代的循环，进入下一次的迭代。与C/C++使用方法完全相同。continue在循环体中使用也有两种方式：带标签、不带标签。语法格式如下：

1
2
continue //不带标签
continue label //带标签，label是标签名

使用案例：

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
    label1: for (int x = 0; x < 5; x++) {
        for (int y = 5; y > 0; y--) {
            if (y == x) {
                continue label1;
            }
            System.out.println(x+","+y);
        }
    }
    System.out.println("Game Over!");
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
0,5
0,4
0,3
0,2
0,1
1,5
1,4
1,3
1,2
2,5
2,4
2,3
3,5
3,4
4,5
Game Over!

由于跳过了 x == y，因此下面的内容没有输出。

1
2
3
4
1,1
2,2
3,3
4,4

Java流程控制实战

判断闰年平年并输出某月的天数

所谓闰年，就是指 2 月有 29 天的那一年。闰年同时满足以下条件：

  • 年份能被 4 整除。
  • 年份若是 100 的整数倍，须被 400 整除，否则是平年。

程序分为四步：
1）新建一个类并在该类中导入需要的 java.util.Scanner 类，同时需要创建该类的入口方法 main()，其实现代码如下：

1
2
3
4
5
6
import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        // 在此处编写其它代码
    }
}

2）在 main() 方法中编写 Java 代码，获取用户输入的年份和月份，其实现代码如下：

1
2
3
4
5
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份（注：必须大于1990年）：");
in year = sc.nextInt();
System.out.println("请输入月份：");
int month = sc.nextInt();

3）根据用户输入的年份，判断该年份是闰年还是平年，其实现代码如下：

1
2
3
4
5
6
7
8
boolean isRen;
if((year%4==0 && year%100!=0)||(year%400==0)) {
    System.out.println(year+"闰年");
    isRen = true;
} else {
    System.out.println(year+"平年");
    isRen = false;
}

4）根据用户输入的月份，判断该月的天数，其实现代码如下：

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
int day = 0;
switch(month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        day = 31;
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        day = 30;
        break;
    default:
        if(isRen) {
            day = 29;
        } else {
            day = 28;
        }
        break;
}
System.out.println(year+"年"+month+"月共有"+day+"天");

输出杨辉三角形

1
2
3
4
5
6
7
8
打印杨辉三角形的行数：7
      1
     1 1
    1 2 1
   1 3 3 1
  1 4 6 4 1
 1 5 10 10 5 1
1 6 15 20 15 6 1

根据目标结果可以发现，num[m,n]处的值等于num[m - 1, n - 1] + num[m - 1, n]

实现步骤如下：

(1) 创建名称为 Test28 的类，在该类中声明 num() 方法，在 num() 方法中传入两个参数，即 x 和 y。其中，x 表示行，y 表示列。num() 方法用于计算第 x 行第 y 列的数值。代码如下：

1
2
3
4
5
6
7
public static int num(int x, int y) {
    if (y == 1 || y == x) {
        return 1;
    }
    int c = num(x - 1, y - 1) + num(x - 1, y);
    return c;
}

(2) 创建名称为 calculate 的方法，在该方法中传入一个 int 类型的参数，该参数表示打印杨辉三角形的行数。代码如下：

1
2
3
4
5
6
7
8
9
10
11
public static void calculate(int row) {
    for (int i = 1; i <= row; i++) {
        for (int j = 1; j <= row - i; j++) {
            System.out.print(" ");
        }
        for (int j = 1; j <= i; j++) { // 打印空格后面的字符, 从第1 列开始往后打印
            System.out.print(num(i, j) + " ");
        }
        System.out.println();
    }
}

(3) 在 main() 方法中添加代码，首先接收用户在控制台输入的打印行数，然后将行数作为参数传入到调用的 calculate() 方法中。代码如下：

1
2
3
4
5
6
public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.print("打印杨辉三角形的行数：");
    int row = scan.nextInt();
    calculate(row);
}

(4) 运行代码进行测试，其运行结果如下所示：

1
2
3
4
5
6
7
8
打印杨辉三角形的行数：7
      1
     1 1
    1 2 1
   1 3 3 1
  1 4 6 4 1
 1 5 10 10 5 1
1 6 15 20 15 6 1

Java选择结构和循环结构的总结

一般写循环语句时，分以下三步走：

  1. 定义初始值
  2. 设置判断条件
  3. 初始值变化

除此之外，JDK5 还提供了一种新的循环：foreach 循环，能以更简单的方式来遍历集合、数组的元素。

Java 还提供了 break、continue 和 return 来控制程序的循环结构，作用如下：

  • break：表示跳出当前层循环
  • continue：表示跳出本次循环，进入下一次循环
  • return：跳出当前方法的循环
 Comments
Comment plugin failed to load
Loading comment plugin
  1. Java流程控制语句
    1. Java语句
    2. Java if-else
    3. Java switch case
      1. Java项目实战：实现淡旺季飞机票打折（switch case版）
      2. Java项目实战：根据出生日期计算（判断）星座（switch case版）
    4. Java while
    5. Java for
    6. Java foreach
    7. Java return
    8. Java break
    9. Java continue
    10. Java流程控制实战
      1. 判断闰年平年并输出某月的天数
      2. 输出杨辉三角形
    11. Java选择结构和循环结构的总结
© 2020 - 2024    Q7nl1s
Powered by Hexo & Theme Keep
Unique Visitor Page View
  1. Java流程控制语句
    1. Java语句
    2. Java if-else
    3. Java switch case
      1. Java项目实战：实现淡旺季飞机票打折（switch case版）
      2. Java项目实战：根据出生日期计算（判断）星座（switch case版）
    4. Java while
    5. Java for
    6. Java foreach
    7. Java return
    8. Java break
    9. Java continue
    10. Java流程控制实战
      1. 判断闰年平年并输出某月的天数
      2. 输出杨辉三角形
    11. Java选择结构和循环结构的总结