Java讲课笔记06：选择结构与条件循环

零、本讲学习目标

1、掌握if和switch条件语句的使用

2、掌握while和do…while循环结构语句的使用

一、结构化程序设计

1、结构化基本原则

（1）自顶向下

程序设计时，应先考虑总体，后考虑细节；先考虑全局目标，后考虑局部目标。不要一开始就过多追求众多的细节，先从最上层总目标开始设计，逐步使问题具体化。

（2）逐步求精

对复杂问题，应设计一些子目标作为过渡，逐步细化。

（3）模块化

一个复杂问题，肯定是由若干稍简单的问题构成。模块化是把程序要解决的总目标分解为子目标，再进一步分解为具体的小目标，把每一个小目标称为一个模块。

（4）限制使用goto语句

在程序比较简单是用goto语句是比较灵活，但是当程序比较复杂时很容易造成程序流程的混乱。利用goto语句对以后的后别人看程序是很难理解。调试程序的过程也会变得很困难。

2、三种流程控制结构

（1）顺序结构（Sequence Structure）

（2）选择结构（Selection Structure）

（3）循环结构（Loop Structure）

循环结构有两种情况：
（1）前测试条件循环：先检票后上车（有可能一次循环操作也不执行）
（2）后测试条件循环：先上车后检票（无论如何至少要执行一次循环操作）

二、顺序结构

有一个入口和一个出口，按从上向下依的顺序执行各语句。

（一）顺序结构示意图

（二）顺序结构案例演示

案例1、计算三角形面积

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：计算三角形面积
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example601 {
    public static void main(String[] args) {
        // 声明部分
        double a, b, c, p, s;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("a = ");
        a = sc.nextDouble();
        System.out.print("b = ");
        b = sc.nextDouble();
        System.out.print("c = ");
        c = sc.nextDouble();

        // 处理部分
        p = (a + b + c) / 2;
        s = Math.sqrt(p * (p - a) * (p - b) * (p - c));

        // 输出部分
        System.out.println("s = " + s);
    }
}

运行程序，查看结果：

但是，如果输入的a，b，c构不成三角形，结果如下：

案例2、求解一元二次方程

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：求解一元二次方程
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example602 {
    public static void main(String[] args) {
        // 声明部分
        double a, b, c, delta, x1, x2;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("a = ");
        a = sc.nextDouble();
        System.out.print("b = ");
        b = sc.nextDouble();
        System.out.print("c = ");
        c = sc.nextDouble();

        // 处理部分
        delta = b * b - 4 * a * c;
        x1 = (-b + Math.sqrt(delta)) / (2 * a);
        x2 = (-b - Math.sqrt(delta)) / (2 * a);

        // 输出部分
        System.out.println("x1 = " + x1);
        System.out.println("x2 = " + x2);
    }
}

运行程序，查看结果：


但是，输入的a，b，c导致了判别式小于零，得不到计算结果。

虽然程序运行没有抛出异常，但是NaN也不是我们想要看到的。

（三）顺序结构小结

顺序结构很简单，按照语句书写次序，依次从上往下执行。上述两个案例，大家可以看到，遇到不能求解的情形，就是给出一个NaN的结果，那并不是我们想要的结果。我们需要事先对能否求解进行判断，如果能求解，那么我们就计算给出结果；如果不能求解，我们就给出相应提示，告诉用户不能求解，这样处理，对用户比较友好。怎么根据情况不同来执行不同的操作呢？这就是我们下面要讲的选择结构。

三、选择结构

在实际生活中经常需要作出一些判断，比如开车来到一个十字路口，这时需要对红绿灯进行判断，如果前面是红灯，就停车等候，如果是绿灯，就通行。Java中有一种特殊的语句叫做选择结构语句，它也需要对一些条件作出判断，从而决定执行哪一段代码。

（一）选择结构概述

程序发生分支，根据判断框内的条件是否被满足来选择执行一块还是执行 B 块。无论条件是否被满足，只能选择执行一或 B 中之一，不能执行完一块后又执行 B 块无论走哪条路径，都要经过 C 点，然后脱离本选择结构框。

根据处理不同情况的个数，我们下面分成单分支结构、双分支结构与多分支结构来进行讲解。

（二）单分支结构

1、语法格式

if (条件) {
   语句组 
}

说明：如果语句组只是一条语句，那么花括号是可以省略的。

2、执行情况

如果条件成立，就执行语句组，否则啥也不做。

3、案例演示：判断一个数是否是偶数。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：判断奇偶数
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example603 {
    public static void main(String[] args) {
        // 声明部分
        int n;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("n = ");
        n = sc.nextInt();

        // 处理部分 + 输出部分
        if (n % 2 == 0) {
            System.out.println(n + "是一个偶数。");
        }
    }
}

运行程序，查看结果：


单分支结构经常会嵌套在循环结构里，起一个过滤的作用，比如要对某个范围里满足什么条件的数进行处理。

补充案例：输出1~100之间能被3或5整除的数，要求每行输出5个数。

（三）双分支结构

1、语法格式

if (条件) {
   语句组1
} else {
   语句组2
}

2、执行情况

双分支结构就是我们通常讲的“花开两朵，各表一枝”或者“鱼和熊掌不可兼得”。语句组1与语句组2，根据条件成立与否，只有其中一个会被执行。

3、案例演示：计算三角形面积

提示：两步（判断 + 计算）
（1）利用三边关系定理判断能否构成三角形；
三边关系定理：任意两边之和大于第三边。
（2）如果能构成三角形，利用海伦公式来计算。
三边为 $a, b, c$，半周长 $p=\displaystyle \frac{a+b+c}{2}$
面积 $area=\displaystyle \sqrt{p(p-a)(p-b)(p-c)}$

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：计算三角形面积
 *       要判断能否构成三角形
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example604 {
    public static void main(String[] args) {
        // 声明部分
        double a, b, c, p, s;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("a = ");
        a = sc.nextDouble();
        System.out.print("b = ");
        b = sc.nextDouble();
        System.out.print("c = ");
        c = sc.nextDouble();

        // 处理部分 + 输出部分
        if (a + b > c && b + c > a && c + a > b) {
            p = (a + b + c) / 2;
            s = Math.sqrt(p * (p - a) * (p - b) * (p - c));
            System.out.println("s = " + s);
        } else {
            System.out.println(a + "、" + b + "、" + c + "无法构成三角形！");
        }
    }
}

运行程序，查看结果：


问题：判断条件能否换种花样呢？

说明：选择结构的条件是根据海伦公式（被开方数要非负）来确定的。
$p>a \Leftrightarrow \displaystyle \frac{a+b+c}{2}>a \Leftrightarrow a+b+c>2a \Leftrightarrow b+c>a$
$p>b \Leftrightarrow \displaystyle \frac{a+b+c}{2}>b \Leftrightarrow a+b+c>2b \Leftrightarrow c+a>b$
$p>c \Leftrightarrow \displaystyle \frac{a+b+c}{2}>c \Leftrightarrow a+b+c>2c \Leftrightarrow a+b>c$
由此可见，两种判断条件其实是等价的，只是表现形式不同而已。

同学们，将代码修改之后运行，看一看是否能得到相同的运行结果。

大家可以看一下完成同样任务的Python代码：

4、课堂练习：判断一个年份是闰年还是平年。

其实，在上一讲的逻辑运算部分，大家已经完成了这个课堂练习。

（四）多分支结构

1、四种处理方式

多分支结构可有四种处理方式：并列式、嵌套式、延拓式、开关式

（1）并列式多分支结构

if (条件1) {
    语句组1
}
if (条件2) {
    语句组2
}
……
if (条件n) {
    语句组n
}

（2）嵌套式多分支结构

if (条件) {
    if (条件1) {
       语句组1
    } else {
       ……
    }
} else {
    if (条件2) {
       语句组2
    } else {
       ……
    }
}

（3）延拓式多分支结构

if (条件1) {
    语句组1
} else if (条件2) {
    语句组2
} 
……
} else if (条件n) {
    语句组n
} else {
    语句组n+1
}

（4）开关式多分支结构

switch (测试表达式) {
    case 值1:
        语句组1
        break;
    case 值2:
        语句组2
        break;
     ……
    case 值n:
        语句组n
        break;
    default:
        语句组n+1
}

2、案例演示：评定成绩等级。

(100, +∞)：超出范围
[90, 100]：优秀
[80, 90)：良好
[70, 80)：中等
[60, 70)：及格
[0, 60)：不及格
(-∞, 0)：超出范围

方法一、采用并列式多分支结构

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：并列式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example605 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100) {
            level = "超出范围";
        }
        if (score >= 90 && score <= 100) {
            level = "优秀";
        }
        if (score >= 80 && score < 90) {
            level = "良好";
        }
        if (score >= 70 && score < 80) {
            level = "中等";
        }
        if (score >= 60 && score < 70) {
            level = "及格";
        }
        if (score >= 0 && score < 60) {
            level = "不及格";
        }
        if (score < 0) {
            level = "超出范围";
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：







总结：并列式多分支结构，优点是易于理解，但缺点是效率低（思考一下，为什么效率低）。

其实，这个程序可以作点优化，因为成绩大于100分或小于0分都是超出范围，所以可以将这两个并列的分之合而为一，如下图所示：

方法二、采用嵌套式多分支结构

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：嵌套式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example606 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100) {
            level = "超出范围";
        } else {
            if (score >= 90) {
                level = "优秀";
            } else {
                if (score >= 80) {
                    level = "良好";
                } else {
                    if (score >= 70) {
                        level = "中等";
                    } else {
                        if (score >= 60) {
                            level = "及格";
                        } else {
                            if (score >= 0) {
                                level = "不及格";
                            } else {
                                level = "超出范围";
                            }
                        }
                    }
                }
            }
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：







刚才是从大到小依次判断分数段，其实也可以反过来，从小到大依次判断分数段，如下图所示：


总结：嵌套式多分支结构，优点是层次分明、效率高，但缺点是嵌套层次太多时显得很繁。

大家可以对照一下Python代码：

课堂作业： 网上搜一搜，了解Java语言最多允许嵌套多少层，顺带也查一查Python语言如何。

方法三、采用延拓式多分支结构

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：延拓式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example607 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100) {
            level = "超出范围";
        } else if (score >= 90) {
            level = "优秀";
        } else if (score >= 80) {
            level = "良好";
        } else if (score >= 70) {
            level = "中等";
        } else if (score >= 60) {
            level = "及格";
        } else if (score >= 0) {
            level = "不及格";
        } else {
            level = "超出范围";
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：







刚才是从大到小依次判断分数段，其实也可以反过来，从小到大依次判断分数段，如下图所示：


总结：延拓式多分支结构，优点是只有一层，并且效率高。希望同学们务必掌握这一种多分支处理方式。

大家可以对照一下Python代码：

方法四、采用开关式多分支结构

关键点在于将成绩变量取整之后再整除10，以便将各个分数段转换成离散的整数值，这样才能用开关式多分支结构来进行处理。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：开关式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example608 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100 || score < 0) {
            level = "超出范围";
        } else {
            switch ((int) score / 10) {
                case 10:
                case 9:
                    level = "优秀";
                    break;
                case 8:
                    level = "良好";
                    break;
                case 7:
                    level = "中等";
                    break;
                case 6:
                    level = "及格";
                    break;
                default:
                    level = "不及格";
            }
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：







总结：开关式多分支结构，优点是书写简洁，并且效率高，但缺点是只能针对离散型的情况进行处理。

开关式多分支结构里的测试表达式，类型可以是整数、字符、甚至可以是字符串。

运行程序，查看结果：

3、课堂练习：计算分段函数值

$y=\begin{cases} 3x^2-1 &x\geq1 &(1)\\ -2x + 5 &-1\le x\lt 1 &(2)\\ 4x^2+3 &x\lt -1 &(3) \end{cases}$



我们在编写程序解决问题时，尽量开拓我们的思维，做到一题多解，正所谓条条道路通罗马。既然是一题多解，那就存在一个评判不同解法的问题，要学会了解不同解法的优劣。其实，做任何选择，都存在一个策略性的考虑。

All roads lead to Rome. 条条道路通罗马。

算法是程序的灵魂！！！

通过Python版猜数游戏引入循环结构！！！

三、为什么要用循环

如果要求输出一百遍“好好学习，天天向上！”，那你会怎么做？

1、老老实实的笨方法

System.out.println("第1遍写：好好学习，天天向上！"); 
System.out.println("第2遍写：好好学习，天天向上！"); 
System.out.println("第3遍写：好好学习，天天向上！"); 
System.out.println("第4遍写：好好学习，天天向上！"); 
……
System.out.println("第100遍写：好好学习，天天向上！");     

此方法显然很糟糕，如果要你输出一万遍，那岂不令人崩溃？

2、采用循环结构的巧方法

（1）采用计数循环（for循环）

package net.hw.lesson06;

/**
 * 功能：重复口号一百遍
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example609 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {// 循环头：初始条件、循环条件、更新条件
            System.out.println("第" + i + "遍写：好好学习，天天向上！");
        }
    }
}

运行程序，查看结果：

大家可以参看一下Python代码完成同样的任务：

（2）采用条件循环（while循环）

package net.hw.lesson06;

/**
 * 功能：重复口号一百遍
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example610 {
    public static void main(String[] args) {
        int i = 1; // 初始条件
        while (i <= 100) { // 循环条件
            System.out.println("第" + i + "遍写：好好学习，天天向上！");
            i++; // 更新条件
        }
    }
}

运行程序，查看结果：

大家可以参看用Python代码完成同样的任务：

四、条件循环

条件循环是根据条件来决定是否要执行循环或终止循环。
条件循环有两种，前测试条件循环while循环，后测试条件循环do…while循环。

（一）while循环

1、语法格式

初始条件
while (循环条件) {
     语句块
     break|continue;
     更新条件
}

2、执行情况

首先判断循环条件是真还是假，如果是真的，执行循环体，然后再次判断循环条件。如果是真的，继续循环，直到循环条件变成假的。有一种特殊情况：如果第一次判断循环条件就不成立，那么一次循环也不执行。

3、案例演示

任务1、演示死循环（永真循环）

package net.hw.lesson06;

/**
 * 功能：演示死循环（永真循环）
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example611 {
    public static void main(String[] args) {
        // 理论上是死循环，但实际上会结束
        int i = 1; // 初始条件
        while (i >= 1) { // 循环条件
            System.out.println("i = " + i);
            i = i + 10000; // 更新条件
        }
        System.err.println("i = " + i);

        // 最直接了当的死循环
        while (true) {
            System.out.println("我要出去玩！");
        }
    }
}

运行程序，查看结果：


会一直输出“我要出去玩！”，永远都不会结束，除非我们强制终止应用程序。

任务2、计算1 + 2 + 3 + …… + 100的值

这是一个非常经典的数学计算问题：公差为1的等差数列求和。

package net.hw.lesson06;

/**
 * 功能：计算1 + 2 + 3 + …… + 100的值
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example612 {
    public static void main(String[] args) {
        int i, sum = 0;

        i = 1; // 初始条件
        while (i <= 100) { // 循环条件
            sum += i; 
            i++; // 更新条件
        }

        System.out.println("1 + 2 + 3 + …… + 100 = " + sum);
    }
}

只要i <= 100成立，循环都会继续，直到i = 101，不满足条件了，循环才终止。

运行程序，查看结果：

修改一下代码，输出循环结束后循环变量i的值：

大家可以参看一下完成同样任务的Python代码：

课堂练习：编程计算1 + 3 + 5 + …… + 99的值

提示：有三种方法可以解决此问题。
（1）修改循环的更新条件：i = i + 2;
（2）在循环结构里嵌套一个过滤器：if (i % 2 == 1) sum += i;
（3）修改循环条件：i <= 50，修改累加语句 sum += 2 * i - 1;

任务3、打印全部水仙花数

所谓水仙花数，是指等于其各位数字立方和的三位数。

$153=1^3+5^3+3^3$
$370=3^3+7^3+0^3$
$371=3^3+7^3+1^3$
$407=4^3+0^3+7^3$

分析问题，首先水仙花数是三位数，那么我们可以确定范围：100~999，这个我们可以通过循环结构来搞定：

n = 100;
while (n <= 999) {
    n++;
}

然后对于这个范围的每个数n，我们要去判断它是否等于其各位数字的立方和，这里的难点或关键在于如何分解一个三位数，得到它的每位数字。

假设我们已经把三位数n分解成百位数p3，十位数p2，个位数p1，
这样我们的筛选条件就可以写出来：n == p3 * p3 * p3 + p2 * p2 * p2 + p1 * p1 * p1。

如何拆分一个三位数n呢？

首先求n的个位数：n % 10
然后要将三位数变成两位数：n = n / 10;
对于新的两位数n，又求它的个位数：n % 10
然后要将两位数变成一位数：n = n / 10;

也就是说我们可以交替使用求余和整除运算将一个三位数拆分，得到它的个位数、十位数和百位数。当然这个分解方法可以推广到任何多位数的拆分。

package net.hw.lesson06;

/**
 * 功能：打印水仙花数
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example613 {
    public static void main(String[] args) {
        // 声明部分
        int n;
        int p3; // 百位数
        int p2; // 十位数
        int p1; // 个位数

        // 处理部分
        n = 100; // 初始条件
        while (n <= 999) {// 循环条件
            p1 = n % 10; // 得到个位数
            p2 = n / 10 % 10; // 得到十位数
            p3 = n / 100; // 得到百位数
            if (n == p1 * p1 * p1 + p2 * p2 * p2 + p3 * p3 * p3) {// if负责筛选工作
                System.out.println(n + " = " + p3 + "^3 + " + p2 + "^3 + " + p1 + "^3");
            }
            n++; // 更新条件
        }
    }
}

大家可以参看一下完成同样任务的Python代码：

（二）do…while循环

1、语法格式

初始条件
do {
     语句块
     break|continue;
     更新条件
} while (循环条件);

2、执行情况

首先执行一次循环，然后判断循环条件，如果为真，继续循环，直到条件为假时结束循环。后测试当型循环，属于先上车后买票，无论如何都会执行一次循环。

3、案例演示：计算1 + 2 + 3 + …… + 100的值

package net.hw.lesson06;

/**
 * 功能：计算1 + 2 + 3 + …… + 100的值
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example614 {
    public static void main(String[] args) {
        int i, sum = 0;

        i = 1; // 初始条件
        do {
            sum += i;
            i++; // 更新条件
        } while (i <= 100); // 循环条件

        System.out.println("1 + 2 + 3 + …… + 100 = " + sum);
    }
}

运行程序，查看结果：

五、课后作业

1、输出所有的玫瑰花数

所谓玫瑰花数，是指等于其各位数字四次方之和的四位数。

$1634=1^4+6^4+3^4+4^4$
$8208=8^4+2^4+0^4+8^4$
$9474=9^4+4^4+7^4+4^4$

2、完成猜数游戏，处理只玩一次就结束的情况

3、判断一个整数是否是素数

什么是素数？一个整数除了1和本身之外没有其它因子，这个整数就是素数。比如，2、3、5、7、11、13……这些整数都是素数，但是我们来看6，除了1和6之外，还有其它因子2和3，6 = 2 * 3，因此6是合数。有一个特殊情况，1既不是素数，也不是合数。

4、打印输出100以内的全部素数，每行打印5个素数

5、解决征婚测试问题

六、补充案例

1、幸运抽奖

输入四位数的会员卡号，如果卡号的百位数等于计算机产生的随机数，那就参与幸运抽奖。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：输入四位数的会员卡号，如果卡号的百位数
 * 等于计算机产生的随机数，那就参与幸运抽奖。
 * 作者：华卫
 * 日期：2020年11月12日
 */
public class Example615 {
    public static void main(String[] args) {
        //声明部分
        int cardNo; //会员卡号
        int hunNum; //百位数
        int rndNum; //随机数
        Scanner sc = new Scanner(System.in);//扫描器

        //输入部分
        System.out.print("输入会员卡号：");
        cardNo = sc.nextInt();//接收一个整数

        // 处理部分：首先要判断卡号是否合法，如果卡号合法，再看其百位数是否等于随机数，又有两种结果
        // 采用if嵌套来实现
        if (cardNo >= 1000 && cardNo <= 9999) {
            // 取出会员卡号的百位数
            hunNum = cardNo / 100 % 10;
            // 计算机产生[0,9]之间的随机整数（要掌握产生[a,b]之间随机整数的方法：伸缩变换-->取整-->平移变换）
            rndNum = (int) (Math.random() * 10);
            System.out.println("计算机产生的随机数：" + rndNum);
            if (hunNum == rndNum) {
                System.out.println("恭喜，你成为幸运会员！");
            } else {
                System.out.println("遗憾，欢迎你再来！");
            }
        } else {
            System.err.println("糟糕，卡号错误，不能参与幸运抽奖活动！");
        }
    }
}

运行程序，查看结果：

2、给出年月日，确定它是该年的第几天

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：给出年月日，确定它是该年的第几天。
 * 作者：华卫
 * 日期：2020年4月12日
 */

public class Example616 {
    public static void main(String[] args) {
        // 声明部分
        int year, month, day; // 年月日
        int days; // 第几天
        boolean isLeapYear; // 是否为闰年
        Scanner sc = new Scanner(System.in); // 扫描器

        // 输入部分
        System.out.print("year = ");
        year = sc.nextInt();
        System.out.print("month = ");
        month = sc.nextInt();
        System.out.print("day = ");
        day = sc.nextInt();

        // 处理部分
        isLeapYear = year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
        int sum = 0; // 当前月份之前几个月的总天数
        switch (month) {
            case 1:
                sum = 0;
                break;
            case 2:
                sum = 31;
                break;
            case 3:
                if (isLeapYear) {
                    sum = 31 + 29;
                } else {
                    sum = 31 + 28;
                }
                break;
            case 4:
                if (isLeapYear) {
                    sum = 31 + 29 + 31;
                } else {
                    sum = 31 + 28 + 31;
                }
                break;
            case 5:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30;
                }
                break;
            case 6:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31;
                }
                break;
            case 7:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30;
                }
                break;
            case 8:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31;
                }
                break;
            case 9:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31;
                }
                break;
            case 10:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30;
                }
                break;
            case 11:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31;
                }
                break;
            case 12:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30;
                }
                break;
        }
        days = sum + day;

        // 输出部分
        System.out.println(year + "年" + month + "月" + day + "日是该年的第" + days + "天。");
    }
}

运行程序，查看结果：

3、根据获奖名次给予奖励

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：根据获奖名次给予奖励
 * 作者：华卫
 * 日期：2020年4月12日
 */

public class Example617 {
    public static void main(String[] args) {
        // 声明部分
        int rank; //获奖名次
        String reward; //给予的奖励
        Scanner sc = new Scanner(System.in); //扫描器
        //输入部分
        System.out.print("输入获奖名次：");
        rank = sc.nextInt(); //接收一个整数
        //处理部分
        switch (rank) {
            case 1:
                reward = "参加麻省理工大学组织的1个月夏令营！";
                break;
            case 2:
                reward = "奖励惠普笔记本电脑一部！";
                break;
            case 3:
                reward = "奖励移动硬盘一个！";
                break;
            default:
                reward = "没有任何奖励！";
                break;
        }
        //输出部分
        System.out.println(reward);
    }
}

运行程序，查看结果：

4、购物打折

实现购物打折；普通顾客购物满100元打9折；会员购物打8折；会员购物满200元打7.5折。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：实现购物打折；普通顾客购物满100元打9折；
 * 会员购物打8折；会员购物满200元打7.5折。
 * 作者：华卫
 * 日期：2020年4月12日
 */

public class Example618 {
    public static void main(String[] args) {
        // 声明部分
        String rank; // 用户级别
        double money; // 购物金额
        double discount; // 购物折扣
        double pay; // 实付金额
        Scanner sc = new Scanner(System.in);// 扫描器

        // 输入部分
        System.out.print("输入用户级别：");
        rank = sc.next(); // 接收字符串
        System.out.print("输入购物金额：");
        money = sc.nextDouble(); // 接收实数

        // 处理部分
        if (rank.equals("会员")) { // 判断是否是会员
            if (money >= 200) {
                discount = 0.75;
            } else {
                discount = 0.8;
            }
        } else {
            if (money >= 100) {
                discount = 0.9;
            } else {
                discount = 1.0;
            }
        }
        pay = money * discount;

        // 输出部分
        if (rank.equals("会员")) {
            System.out.println("会员：购物打" + discount * 10 + "折，实付金额：" + pay);
        } else {
            if (discount == 1.0) {
                System.out.println("顾客：购物不打折，实付金额：" + pay);
            } else {
                System.out.println("顾客：购物打" + discount * 10 + "折，实付金额：" + pay);
            }
        }
    }
}

运行程序，查看结果：

5、多级购物菜单系统

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：设计购物系统的多级菜单
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example619 {
    public static void main(String[] args) {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示登录菜单
        System.out.println("   登录菜单");
        System.out.println("==============");
        System.out.println(" 1. 登录系统");
        System.out.println(" 2. 退出系统");
        System.out.println("==============");
        System.out.print("输入菜单号(1,2)：");

        choice = sc.nextInt();
        switch (choice) {
            case 1:
                login(); // 调用登录系统的方法
                break;
            case 2:
                System.out.println("谢谢使用！");
                System.exit(0); // 退出应用程序
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }

    /**
     * 定义系统登录方法
     */
    private static void login() {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示主菜单
        System.out.println("       主菜单");
        System.out.println("==================");
        System.out.println(" 1. 客户信息管理");
        System.out.println(" 2. 购物结算");
        System.out.println(" 3. 真情回馈");
        System.out.println(" 4. 注销");
        System.out.println("==================");
        System.out.print("输入菜单号(1,2,3,4)：");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                customer_management(); //调用客户信息管理模块
                break;
            case 2:
                System.out.println("进入购物结算模块！");
                break;
            case 3:
                sincere_feedback(); //调用真情回馈模块
                break;
            case 4:
                System.out.println("登录账号已注销！");
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }

    /**
     * 定义真情回馈方法
     */
    private static void sincere_feedback() {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示真情回馈菜单
        System.out.println("     真情回馈");
        System.out.println("=================");
        System.out.println(" 1. 幸运大放送");
        System.out.println(" 2. 幸运抽奖");
        System.out.println(" 3. 生日问候");
        System.out.println("=================");
        System.out.print("输入菜单号(1,2,3)：");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                System.out.println("进入幸运大放送模块！");
                break;
            case 2:
                System.out.println("进入幸运抽奖模块！");
                break;
            case 3:
                System.out.println("朋友，祝你生日快乐！");
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }

    /**
     * 定义客户信息管理方法
     */
    private static void customer_management() {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示客户信息管理菜单
        System.out.println("    客户信息管理");
        System.out.println("=====================");
        System.out.println(" 1. 显示所有客户信息");
        System.out.println(" 2. 添加客户信息");
        System.out.println(" 3. 修改客户信息");
        System.out.println(" 4. 查询客户信息");
        System.out.println("=====================");
        System.out.print("输入菜单号(1,2,3,4)：");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                System.out.println("进入显示所有客户信息模块！");
                break;
            case 2:
                System.out.println("进入添加客户信息模块！");
                break;
            case 3:
                System.out.println("进入修改客户信息模块！");
                break;
            case 4:
                System.out.println("进入查询客户信息模块！");
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }
}

运行程序，查看结果：

   登录菜单
==============
 1. 登录系统
 2. 退出系统
==============
输入菜单号(1,2)：1
       主菜单
==================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
==================
输入菜单号(1,2,3,4)：1
    客户信息管理
=====================
 1. 显示所有客户信息
 2. 添加客户信息
 3. 修改客户信息
 4. 查询客户信息
=====================
输入菜单号(1,2,3,4)：4
进入查询客户信息模块！

本程序存在不足之处，虽然能逐层调用下一级菜单，但是却不能逐层返回上一级菜单，要实现逐层返回功能，那得利用到循环结构。

6、可进可退的多级购物菜单系统

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：设计购物系统的多级菜单
 * 要求菜单操作可进可退
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example620 {
    public static void main(String[] args) {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示登录菜单
            System.out.println(" 登录菜单");
            System.out.println("=============");
            System.out.println(" 1. 登录系统");
            System.out.println(" 2. 退出系统");
            System.out.println("=============");
            System.out.print("输入菜单号(1,2)：");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    login(); // 调用登录系统的方法
                    break;
                case 2:
                    isReturn = true; // 要返回
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                System.out.println("谢谢使用！");
                break; // 跳出循环
            }
        }
    }

    // 定义登录系统的方法
    private static void login() {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示主菜单
            System.out.println("     主菜单");
            System.out.println("================");
            System.out.println(" 1. 客户信息管理");
            System.out.println(" 2. 购物结算");
            System.out.println(" 3. 真情回馈");
            System.out.println(" 4. 注销");
            System.out.println("================");
            System.out.print("输入菜单号(1,2,3,4)：");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    customer_management(); // 调用客户信息管理模块
                    break;
                case 2:
                    System.out.println("进入购物结算模块！");
                    break;
                case 3:
                    sincere_feedback(); // 调用真情回馈模块
                    break;
                case 4:
                    isReturn = true; // 要返回
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                System.out.println("登录账号已注销！");
                break;
            }
        }
    }

    // 定义真情回馈的方法
    private static void sincere_feedback() {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示真情回馈菜单
            System.out.println("购物管理系统>真情回馈");
            System.out.println("==================");
            System.out.println(" 1. 幸运大放送");
            System.out.println(" 2. 幸运抽奖");
            System.out.println(" 3. 生日问候");
            System.out.println(" 4. 返回上级菜单");
            System.out.println("==================");
            System.out.print("输入菜单号(1,2,3,4)：");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    System.out.println("进入幸运大放送模块！");
                    break;
                case 2:
                    System.out.println("进入幸运抽奖模块！");
                    break;
                case 3:
                    System.out.println("朋友，祝你生日快乐！");
                    break;
                case 4:
                    isReturn = true; // 要返回
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                break; // 跳出循环
            }
        }
    }

    // 定义客户信息管理的方法
    private static void customer_management() {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示客户信息管理菜单
            System.out.println("购物管理系统>客户信息管理");
            System.out.println("======================");
            System.out.println(" 1. 显示所有客户信息");
            System.out.println(" 2. 添加客户信息");
            System.out.println(" 3. 修改客户信息");
            System.out.println(" 4. 查询客户信息");
            System.out.println(" 5. 返回上一级菜单");
            System.out.println("======================");
            System.out.print("输入菜单号(1,2,3,4,5)：");
            choice = sc.nextInt();
            switch (choice) {
                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:
                    isReturn = true;
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                break; // 跳出循环
            }
        }
    }
}

运行程序，查看结果：

 登录菜单
=============
 1. 登录系统
 2. 退出系统
=============
输入菜单号(1,2)：1
     主菜单
================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
================
输入菜单号(1,2,3,4)：1
购物管理系统>客户信息管理
======================
 1. 显示所有客户信息
 2. 添加客户信息
 3. 修改客户信息
 4. 查询客户信息
 5. 返回上一级菜单
======================
输入菜单号(1,2,3,4,5)：4
进入查询客户信息模块！
购物管理系统>客户信息管理
======================
 1. 显示所有客户信息
 2. 添加客户信息
 3. 修改客户信息
 4. 查询客户信息
 5. 返回上一级菜单
======================
输入菜单号(1,2,3,4,5)：5
     主菜单
================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
================
输入菜单号(1,2,3,4)：3
购物管理系统>真情回馈
==================
 1. 幸运大放送
 2. 幸运抽奖
 3. 生日问候
 4. 返回上级菜单
==================
输入菜单号(1,2,3,4)：4
     主菜单
================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
================
输入菜单号(1,2,3,4)：4
登录账号已注销！
 登录菜单
=============
 1. 登录系统
 2. 退出系统
=============
输入菜单号(1,2)：2
谢谢使用！

7、四个整数排序

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：输入四个整数进行排序
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example621 {
    public static void main(String[] args) {
        // 声明部分
        int x1, x2, x3, x4, t;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("x1 = ");
        x1 = sc.nextInt();
        System.out.print("x2 = ");
        x2 = sc.nextInt();
        System.out.print("x3 = ");
        x3 = sc.nextInt();
        System.out.print("x4 = ");
        x4 = sc.nextInt();

        // 处理部分（排序：比较+交换）

        // 第一轮比较，让x1成为最大的，需要比较3次
        if (x1 < x2) {
            t = x1;
            x1 = x2;
            x2 = t;
        }
        if (x1 < x3) {
            t = x1;
            x1 = x3;
            x3 = t;
        }
        if (x1 < x4) {
            t = x1;
            x1 = x4;
            x4 = t;
        }

        // 第二轮比较，让x2成为第二大的，需要比较2次
        if (x2 < x3) {
            t = x2;
            x2 = x3;
            x3 = t;
        }
        if (x2 < x4) {
            t = x2;
            x2 = x4;
            x4 = t;
        }

        // 第三轮比较，让x3成为第三大的，需要比较1次
        if (x3 < x4) {
            t = x3;
            x3 = x4;
            x4 = t;
        }

        System.out.println("降序：" + x1 + "  " + x2 + "  " + x3 + "  " + x4);

        // 第一轮比较，让x1成为最小的，需要比较3次
        if (x1 > x2) {
            t = x1;
            x1 = x2;
            x2 = t;
        }
        if (x1 > x3) {
            t = x1;
            x1 = x3;
            x3 = t;
        }
        if (x1 > x4) {
            t = x1;
            x1 = x4;
            x4 = t;
        }

        // 第二轮比较，让x2成为第二小的，需要比较2次
        if (x2 > x3) {
            t = x2;
            x2 = x3;
            x3 = t;
        }
        if (x2 > x4) {
            t = x2;
            x2 = x4;
            x4 = t;
        }

        // 第三轮比较，让x3成为第三小的，需要比较1次
        if (x3 > x4) {
            t = x3;
            x3 = x4;
            x4 = t;
        }

        System.out.println("升序：" + x1 + "  " + x2 + "  " + x3 + "  " + x4);
    }
}

运行程序，查看结果：

如果要对更多的数据进行排序，那么最好就要用到我们后面将会学习的数组。

8、购物结算，打印购物小票

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：购物结算（要打印购物小票）
 * 有三样商品：衬衫、球鞋、羽毛球
 * 每样商品都有不同的折扣，可以购买
 * 多件，最后计算实付金额
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example622 {
    public static void main(String[] args) {
        // 声明部分
        double shirtPrice = 100, shoePrice = 200, footballPrice = 150; // 三种商品的单价
        int shirtCount = 0, shoeCount = 0, footballCount = 0; // 三种商品的购买数量
        double shirtDiscount = 0.8, shoeDiscount = 0.9, footballDiscount = 0.7; // 三种商品的折扣
        double shirtMoney = 0, shoeMoney = 0, footballMoney = 0; // 三种商品的购买金额
        double totalMoney = 0; // 实付金额
        int choice; // 选择的菜单号
        boolean isCheckOut; // 是否要结账
        Scanner sc = new Scanner(System.in); // 扫描器

        // 处理部分
        while (true) {
            isCheckOut = false; // 不结账
            System.out.println("         简易购物系统");
            System.out.println("=============================");
            System.out.println("1. 衬衫 单价：100 折扣：8折");
            System.out.println("2. 球鞋 单价：200 折扣：9折");
            System.out.println("3. 足球 单价：150 折扣：7折");
            System.out.println("4. 购物结算——打印购物小票");
            System.out.println("=============================");
            System.out.print("输入菜单号（1，2，3，4）：");
            choice = sc.nextInt();

            switch (choice) {
                case 1:
                    shirtMoney = shirtMoney + shirtPrice * shirtDiscount; // 统计衬衫的购买金额
                    shirtCount++; // 统计衬衫的购买数量
                    break;
                case 2:
                    shoeMoney = shoeMoney + shoePrice * shoeDiscount; // 统计球鞋的购买金额
                    shoeCount++; // 统计球鞋的购买数量
                    break;
                case 3:
                    footballMoney = footballMoney + footballPrice * footballDiscount; // 统计足球的购买金额
                    footballCount++; // 统计足球的购买数量
                    break;
                case 4:
                    isCheckOut = true; // 表明要结账
                    break;
                default:
                    System.out.println("\n菜单号输入错误，请重新输入！\n");
                    break;
            }

            System.out.println();
            if (shirtCount > 0) {
                System.out.println("你已购买" + shirtCount + "件衬衫。");
            }
            if (shoeCount > 0) {
                System.out.println("你已购买" + shoeCount + "双球鞋。");
            }
            if (footballCount > 0) {
                System.out.println("你已购买" + footballCount + "个足球。");
            }
            System.out.println();
            if (isCheckOut) { // 判断是否要结账
                System.out.println("\n谢谢惠顾，欢迎再次光临！\n");
                break; // 跳出循环
            }
        }

        totalMoney = shirtMoney + shoeMoney + footballMoney; // 统计购物总金额
        // 打印购物小票
        System.out.println("商品\t单价\t购买数量\t折扣\t购买金额");
        if (shirtCount > 0) {
            System.out.println("衬衫\t" + shirtPrice + "\t" + shirtCount + "\t\t\t" + shirtDiscount * 10 + "\t\t" + shirtMoney);
        }
        if (shoeCount > 0) {
            System.out.println("球鞋\t" + shoePrice + "\t" + shoeCount + "\t\t\t" + shoeDiscount * 10 + "\t\t" + shoeMoney);
        }
        if (footballCount > 0) {
            System.out.println("足球\t" + footballPrice + "\t" + footballCount + "\t\t\t" + footballDiscount * 10 + "\t\t" + footballMoney);
        }
        System.out.println("\n实付金额：" + totalMoney);
    }
}

运行程序，查看结果：

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：1

你已购买1件衬衫。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：2

你已购买1件衬衫。
你已购买1双球鞋。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：2

你已购买1件衬衫。
你已购买2双球鞋。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：3

你已购买1件衬衫。
你已购买2双球鞋。
你已购买1个足球。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：1

你已购买2件衬衫。
你已购买2双球鞋。
你已购买1个足球。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：1

你已购买3件衬衫。
你已购买2双球鞋。
你已购买1个足球。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：4

你已购买3件衬衫。
你已购买2双球鞋。
你已购买1个足球。


谢谢惠顾，欢迎再次光临！

商品	单价	购买数量	折扣	购买金额
衬衫	100.0	3			8.0		240.0
球鞋	200.0	2			9.0		360.0
足球	150.0	1			7.0		105.0

实付金额：705.0