【Java基础】06 专题课：编程案例思维训练

• 目的：复习前半段课程学习的Java编程知识，能够使用所学的知识解决问题，提升同学们的编程能力。

• 涉及到的知识点

  1. 变量、数组
  2. 运算符：基本运算符、关系运算符、逻辑运算符…
  3. 程序流程控制：if、switch；for、while；死循环、循环嵌套
  4. 跳转关键字：break、continue、return。
  5. 方法
  6. …

• 编程思维：使用所学的Java技术解决问题的思维方式和编写代码实现出来的能力。

• 关于提升编程思维和编程能力的建议

  1. 编程思维和编程能力不是一朝一夕形成的，需要时间的沉淀和大量练习。
  2. 前期：先模仿，后期：再创新。
  3. 具体措施：勤于练习代码，勤于思考，孰能生巧。

案例一：买飞机票

• 需求:

  • 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
  • 机票最终优惠价格的计算方案如下：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。

• 分析：

  1. 键盘录入机票的原价，仓位类型，月份信息，调用方法返回机票最终的优惠价格。
  2. 方法内部应该先使用if分支判断月份是是旺季还是淡季，然后使用switch分支判断是头等舱还是经济舱。
  3. 选择对应的折扣进行计算并返回计算的结果，如果信息录入有误返回价位为-1元代表即可。

package test;

import java.util.Scanner;

/**
 * 买飞机票
 */
public class Test01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入机票原价(元)：");
        double originalPrice = scanner.nextDouble();

        System.out.print("请输入当前月份(1~12)：");
        int currentMonth = scanner.nextInt();

        System.out.print("请选择舱位等级(1:头等舱 / 2:经济舱)：");
        int shippingSpace = scanner.nextInt();

        double discountedPrice = calculatingAirFares(originalPrice, currentMonth, shippingSpace);
        if (discountedPrice == -1) {
            System.out.println("信息录入有误!");
        }
        System.out.println("打折后的优惠价格为：" + discountedPrice + "(元)");
    }

    // 计算飞机票价
    public static double calculatingAirFares(double originalPrice, int currentMonth, int shippingSpace) {
        double discountedPrice = 0.0;

        switch (currentMonth) {
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                if (shippingSpace == 1) {
                    discountedPrice = originalPrice * 0.9;
                } else if (shippingSpace == 2) {
                    discountedPrice = originalPrice * 0.85;
                } else {
                    return -1;
                }
                break;
            case 11:
            case 12:
            case 1:
            case 2:
            case 3:
            case 4:
                if (shippingSpace == 1) {
                    discountedPrice = originalPrice * 0.7;
                } else if (shippingSpace == 2) {
                    discountedPrice = originalPrice * 0.65;
                } else {
                    return -1;
                }
                break;
            default:
                return -1;
        }
        return discountedPrice;
    }
}

• 遇到判断值匹配的时一般选择什么结构实现？
  使用switch分支结构实现。

• 遇到判断区间范围的时候一般选择什么结构实现？
  使用if分支结构实现。

---

案例二：找素数

• 需求：判断101到200之间有多少个素数，并输出所有素数。
• 说明：除了1和它本身以外，不能被其他正整数整除，就叫素数。
• 分析：101-200之间的数据可以采用循环依次拿到; 每拿到一个数，判断该数是否是素数。
• 判断规则是：从2开始遍历到该数的一半的数据，看是否有数据可以整除它，有则不是素数，没有则是素数。
• 如果最终判定是素数，即可输出展示。

package test;

/**
 * 找素数
 */
public class Test02 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 101; i <= 200; i++) {
            boolean b = true;
            for (int j = 2; j < i / 2; j++) {
                // 如果当前数字可以整除整数j，说明该数不是素数
                if (i % j ==0){
                    b = false;
                }
            }

            if (b == true){
                sum++;
                System.out.print(i + ", ");
            }
        }
        System.out.println();
        System.out.println("一共有" + sum + "个素数");
    }
}

• 本次案例中是如何确定出该数是素数的，具体如何实现？
  1. 定义了flag标记位
  2. 遍历2到该数的一半的数据去判断是否有整除的数据，有则改变falg标记位的状态。
  3. 最终通过flag的状态判断是否是素数。

---

案例三：开发验证码

• 需求：定义方法实现随机产生一个指定位数的验证码，每位可能是数字、大写、小写字母
• 分析：
  1. 定义一个方法，生成验证码返回：返回值类型是String，需要形参接收位数。
  2. 在方法内部使用for循环依次生成每位随机字符，并连接起来。
  3. 把连接好的随机字符作为一组验证码返回。

package test;

import java.util.Random;

/**
 * 开发验证码
 */
public class Test03 {
    public static void main(String[] args) {
        int digits = 6;
        String verificationCode = generateVerificationCode(digits);
        System.out.println("您的验证码是：" + verificationCode);
    }

    public static String generateVerificationCode(int digits) {
        // 字符池(数字10 + 大写26 + 小写26 = 62个)
        char[] characterPool = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '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', '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'};

        String code = "";
        Random random = new Random();
        // 生成指定位数的验证码
        for (int i = 1; i <= digits; i++) {
            // 生成随机索引，从字符池中抽取字符
            int randomIndex = random.nextInt(characterPool.length);
            code += characterPool[randomIndex];
        }
        return code;
    }
}

其中字符池的另一种添加方法可以是：

package hnn;

import java.util.Random;

public class Demo3
{
    public static void main(String[] args)
    {
        // 创建长度为62的数组，里0-9 a-z A-Z
        char[] chs = new char[62];
        // 记录的是存储元素的索引
        int index = 0;
        for (char ch = '0'; ch <= '9'; ch++) {
            chs[index] = ch;
            index++;
        }
        for (char ch = 'a'; ch <= 'z'; ch++) {
            chs[index] = ch;
            index++;
        }
        for (char ch = 'A'; ch <= 'Z'; ch++) {
            chs[index] = ch;
            index++;
        }
    }
}

• 随机验证码的核心实现逻辑是如何进行的？
  1. 定义一个String类型的变量存储验证码字符。
  2. 定义一个for循环，循环5次。
  3. 随机生成0|1|2的数据，依次代表当前位置要生成数字|大写字母|小写字母。
  4. 把0、1、2交给switch生成对应类型的随机字符，把字符交给String变量。
  5. 循环结束后，返回String类型的变量即是所求的验证码结果。

---

案例四：数组元素的复制

• 需求：把一个数组中的元素复制到另一个新数组中去。
• 分析：
  1. 需要动态初始化一个数组，长度与原数组一样。
  2. 遍历原数组的每个元素，依次赋值给新数组。
  3. 输出两个数组的内容。

package test;

/**
 * 数组元素的复制
 */
public class Test04 {
    public static void main(String[] args) {
        int[] arr1 = {4,5,3,7,8,2,3};

        // 拷贝数组
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }

        // 打印数组
        System.out.print("原来数组：[");
        for (int i = 0; i < arr1.length; i++) {
            if (i == arr1.length - 1) {
                System.out.println(arr1[i] + "]");
            } else {
                System.out.print(arr1[i] + ",");
            }
        }
        System.out.println("地址：" + arr1);

        System.out.print("拷贝数组：[");
        for (int i = 0; i < arr2.length; i++) {
            if (i == arr2.length - 1) {
                System.out.println(arr2[i] + "]");
            } else {
                System.out.print(arr1[i] + ",");
            }
        }
        System.out.println("地址：" + arr2);
    }
}

抽离成方法：

package test;

/**
 * 数组元素的复制
 */
public class Test04 {
    public static void main(String[] args) {
        int[] arr1 = {4,5,3,7,8,2,3};
        // 拷贝数组
        int[] arr2 = copyArr(arr1);
        // 打印数组
        System.out.print("原来数组：");
        printArr(arr1);
        System.out.print("拷贝数组：");
        printArr(arr2);
    }

    // 拷贝数组
    private static int[] copyArr(int[] arr1) {
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        return arr2;
    }

    // 打印数组
    public static void printArr(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        System.out.println("地址：" + arr);
    }
}

• 数组的拷贝是什么意思？
  需要创建新数组，把原来数组的元素赋值过来。(地址是不同的)

---

案例五：评委打分

• 需求：在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。
• 分析：
  1. 把6个评委的分数录入到程序中去 —-> 使用数组
  2. 遍历数组中每个数据，进行累加求和，并找出最高分、最低分。
  3. 按照分数的计算规则算出平均分。

package test;

import java.util.Scanner;

/**
 * 评委打分
 */
public class Test05 {
    public static void main(String[] args) {
        int[] scores = new int[6];
        Scanner scanner = new Scanner(System.in);
        System.out.println("六位评委的打分范围是[0 - 100]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分。");
        for (int i = 0; i < 6; i++) {
            System.out.print("请输入第" + (i + 1) + "位评委分数：");
            scores[i] = scanner.nextInt();
        }
        // 求平均数
        double averageScore = average(scores);
        System.out.println("打分结果为：" + averageScore);
    }

    // 求最大值
    public static int max(int[] scores) {
        int max = scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (scores[i] > max) {
                max = scores[i];
            }
        }
        System.out.println("最大值为：" + max);
        return max;
    }

    // 求最小值
    public static int min(int[] scores) {
        int min = scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (scores[i] < min) {
                min = scores[i];
            }
        }
        System.out.println("最小值为：" + min);
        return min;
    }

    // 求平均数（去掉最大和最小）
    public static double average(int[] scores) {
        // 求和
        double totalScore = 0;
        for (int i = 0; i < 6; i++) {
            totalScore += scores[i];
        }
        System.out.println("六位评委的分数和：" + totalScore);
        // 求最大值
        double max = max(scores);
        // 求最小值
        double min = min(scores);
        // 求平均数
        double averageScore = (totalScore - max - min) / (scores.length - 2);
        return averageScore;
    }
}

• 如何实现评委打分案例？
  1. 定义一个动态初始化的数组用于存储分数数据。
  2. 定义三个变量用于保存最大值、最小值和总和。
  3. 遍历数组中的每个元素，依次进行统计。
  4. 遍历结束后按照规则计算出结果即可。

---

案例六：数字加密

• 需求：
  • 某系统的数字密码：比如1983，采用加密方式进行传输，规则如下：先得到每位数，然后每位数都加上5 , 再对10求余，最后将所有数字反转，得到一串新数。
  • 将每位数据存入到数组中去，遍历数组每位数据按照「规则」进行更改，把更改后的数据从新存入到数组中。
  • 将数组的前后元素进行交换(反转)，数组中的最终元素就是加密后的结果。

加密过程：

package test;

import java.util.Scanner;

/**
 * 数字加密
 */
public class Test06 {
    public static void main(String[] args) {
        int[] arr = {1, 9, 8, 3};

        // 每位加5，再对10取余
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }

        // 将所有数字反转
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        // 把数组中每个数进行拼接，变成加密后的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i]; // 每次循环乘十进位
        }
        System.out.println(number);
    }
}

录入密码并加密：

package test;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 数字加密
 */
public class Test06 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请选择数字密码的位数：");
        int n = scanner.nextInt();

        System.out.print("请输入密码：");
        int password = scanner.nextInt();

        // 将数字转化为数组
        int[] arr = new int[n];
        int index = 0;
        while (password > 0) {
            int ge = password % 10; // 循环提取个位数，直到最后剩一位
            password /= 10; // 循环降位，直到最后为小于10的整数，除以10后忽略小数变成为0，循环停止
            arr[arr.length - 1 - index] = ge; // 从后往前填入数组
            index++;
        }

        System.out.print("密码内容已储存到数组：");
        System.out.print(Arrays.toString(arr)); // 打印数组

        // 每位加5，再对10取余
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }

        // 将所有数字反转
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        // 把数组中每个数进行拼接，变成加密后的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i]; // 每次循环乘十进位
        }
        System.out.println();
        System.out.println("加密后的值为：" + number);
    }
}

• 本次案例中是如何完成数组元素的反转的？
  • 定义2个变量分别占数组的首尾位置。
  • 一个变量往前走，一个变量往后走，同步交换双方位置处的值。

案例拓展：数字解密(选做)

package test;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 数字解密
 */
public class Test06_2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入加密结果的位数：");
        int n = scanner.nextInt();

        System.out.print("请输入加密结果：");
        int passwordAfter = scanner.nextInt();

        // 将数字转化为数组
        int[] arr = new int[n];
        int index = 0;
        while (passwordAfter > 0) {
            int ge = passwordAfter % 10; // 循环提取个位数，直到最后剩一位
            passwordAfter /= 10; // 循环降位，直到最后为小于10的整数，除以10后忽略小数变成为0，循环停止
            arr[arr.length - 1 - index] = ge; // 从后往前填入数组
            index++;
        }

        System.out.print("加密结果已储存到数组：");
        System.out.print(Arrays.toString(arr)); // 打印数组

        // 将所有数字反转回来
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        // 加密过程是“每位加5，再对10取余”，现在解密
        for (int i = 0; i < arr.length; i++) {
            switch (arr[i]){
                case 0:
                    arr[i] = 5;
                    break;
                case 1:
                    arr[i] = 6;
                    break;
                case 2:
                    arr[i] = 7;
                    break;
                case 3:
                    arr[i] = 8;
                    break;
                case 4:
                    arr[i] = 9;
                    break;
                case 5:
                    arr[i] = 0;
                    break;
                case 6:
                    arr[i] = 1;
                    break;
                case 7:
                    arr[i] = 2;
                    break;
                case 8:
                    arr[i] = 3;
                    break;
                case 9:
                    arr[i] = 4;
                    break;
            }
        }

        // 把数组中每个数进行拼接，变成解密后的原密码
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i]; // 每次循环乘十进位
        }
        System.out.println();
        System.out.println("解密后的值为：" + number);
    }
}

---

案例七：模拟双色球(拓展)

业务分析、随机生成一组中奖号码

• 投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1-33中选择；蓝色球号码从1-16中选择。

• 随机一组中奖号码的分析：

  • 中奖号码由6个红球和1个蓝球组成(注意：6个红球要求不能重复)。
  • 可以定义方法用于返回一组中奖号码(7个数据)，返回的形式是一个整型数组

package test;

import java.util.Random;

/**
 * 模拟双色球
 */
public class Test07 {
    public static void main(String[] args) {
        int[] luckyNumbers  = createLuckyNumbers();
    }

    // 生成投注号码（由6红1蓝组成）
    public static int[] createLuckyNumbers() {
        // 创建数组，用于存放中奖号码
        int[] arr = new int[7];

        // 生成红球号码并存放到数组中
        // 红球6个且不能重复，范围是1-33
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNumber = r.nextInt(33) + 1;
            boolean flag = contains(arr, redNumber); // 调用函数，判断是否重复
            if (!flag) {
                // 添加红球号码到数组中
                arr[i] = redNumber;
                i++;
            }
        }

        // 生成蓝球号码并存放到数组中
        // 篮球1个，范围是1-16
        int blueNumber = r.nextInt(16) + 1;
        arr[arr.length - 1] = blueNumber;

        return arr;
    }

    // 判断数组中是否存在某数
    public static boolean contains(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }
}

• 本次案例中是如何去保证随机的6个中奖的红球号码不重复的？
  • 每次随机一个红球号码后去数组中判断是否存在。
  • 存在需要重新随机一个数字直到不重复为止。

用户输入一组双色球号码

• 用户输入一组双色球号码分析：
  • 定义一个方法，该方法可以录入用户输入的6个红球和1个篮球号码
  • 该方法最终需要返回一个数组，数组中就是用户录入的号码（7位）。

package test;

import java.util.Random;
import java.util.Scanner;

/**
 * 模拟双色球
 */
public class Test07 {
    public static void main(String[] args) {
        // 1.生成投注号码
        int[] luckyNumbers = createLuckyNumbers();

        // 2.录入用户输入号码
        int[] usersNumbers = usersInputNumbers();
    }

    // 生成投注号码（由6红1蓝组成）
    public static int[] createLuckyNumbers() {
        // 创建数组，用于存放中奖号码
        int[] arr = new int[7];

        // 生成红球号码并存放到数组中
        // 红球6个且不能重复，范围是1-33
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNumber = r.nextInt(33) + 1;
            boolean flag = contains(arr, redNumber); // 调用函数，判断是否重复
            if (!flag) {
                // 添加红球号码到数组中
                arr[i] = redNumber;
                i++;
            }
        }

        // 生成蓝球号码并存放到数组中
        // 篮球1个，范围是1-16
        int blueNumber = r.nextInt(16) + 1;
        arr[arr.length - 1] = blueNumber;

        return arr;
    }

    // 判断数组中是否存在某数
    public static boolean contains(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }

    // 录入用户输入号码
    public static int[] usersInputNumbers() {
        int[] arr = new int[7];
        Scanner scanner = new Scanner(System.in);
        // 输入6个红球
        for (int i = 0; i < 6; ) {
            System.out.print("请输入第" + (i + 1) + "个红球号码：");
            int redNumber = scanner.nextInt();
            if (redNumber >= 1 && redNumber <= 33) {
                arr[i] = redNumber; // 存到数组中
                i++;
            } else {
                System.out.println("超出限定范围，请输入1-33的整数！");
            }
        }

        // 输入1个蓝球
        while (true) {
            System.out.print("请输入蓝球号码：");
            int blueNumber = scanner.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16) {
                arr[6] = blueNumber;
                break;
            } else {
                System.out.println("超出限定范围，请输入1-16的整数！");
            }
        }

        return arr;
    }
}

判断中奖情况

• 中奖情况判断的分析：
  • 定义一个方法，可以接收中奖号码的数组，用户选号的数组。
  • 根据命中红球数和蓝球数判断最终的中奖情况并输出详情和中奖金额。

package test;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

/**
 * 模拟双色球
 */
public class Test07 {
    public static void main(String[] args) {
        // 1.生成投注号码
        int[] luckyNumbers = createLuckyNumbers();
        System.out.println("中奖号码：" + Arrays.toString(luckyNumbers)); // 打印数组，仅调试时使用

        // 2.录入用户输入号码
        int[] usersNumbers = usersInputNumbers();
        System.out.println("用户选号：" + Arrays.toString(usersNumbers)); // 打印数组，仅调试时使用

        // 3.判断中奖金额
        judge(luckyNumbers, usersNumbers);
    }

    // 生成投注号码（由6红1蓝组成）
    public static int[] createLuckyNumbers() {
        // 创建数组，用于存放中奖号码
        int[] arr = new int[7];

        // 生成红球号码并存放到数组中
        // 红球6个且不能重复，范围是1-33
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNumber = r.nextInt(33) + 1;
            boolean flag = contains(arr, redNumber); // 调用函数，判断是否重复
            if (!flag) {
                // 添加红球号码到数组中
                arr[i] = redNumber;
                i++;
            }
        }

        // 生成蓝球号码并存放到数组中
        // 篮球1个，范围是1-16
        int blueNumber = r.nextInt(16) + 1;
        arr[arr.length - 1] = blueNumber;

        return arr;
    }

    // 判断数组中是否存在某数
    public static boolean contains(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }

    // 录入用户输入号码
    public static int[] usersInputNumbers() {
        int[] arr = new int[7];
        Scanner scanner = new Scanner(System.in);
        // 输入6个红球
        for (int i = 0; i < 6; ) {
            System.out.print("请输入第" + (i + 1) + "个红球号码：");
            int redNumber = scanner.nextInt();
            if (redNumber >= 1 && redNumber <= 33) {
                arr[i] = redNumber; // 存到数组中
                i++;
            } else {
                System.out.println("超出限定范围，请输入1-33的整数！");
            }
        }

        // 输入1个蓝球
        while (true) {
            System.out.print("请输入蓝球号码：");
            int blueNumber = scanner.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16) {
                arr[6] = blueNumber;
                break;
            } else {
                System.out.println("超出限定范围，请输入1-16的整数！");
            }
        }

        return arr;
    }

    // 判断中奖金额
    public static void judge(int[] luckyNumbers, int[] usersNumbers) {
        int red = 0; // 初始化红球中奖个数
        int blue = 0; // 初始化蓝球中奖个数
        // 计算红球中奖个数
        for (int i = 0; i < 6; i++) {
            if (usersNumbers[i] == luckyNumbers[i]) {
                red++;
            }
        }
        // 计算蓝球中奖个数
        if (usersNumbers[6] == luckyNumbers[6]) {
            blue = 1;
        }

        // 判断中奖金额
        if (red == 6 && blue == 1) {
            System.out.println("恭喜您中奖啦，一等奖！奖金最高1000万！");
        } else if (red == 6 && blue == 0) {
            System.out.println("恭喜您中奖啦，二等奖！奖金最高500万！");
        } else if (red == 5 && blue == 1) {
            System.out.println("恭喜您中奖啦，三等奖！奖金3000元！");
        } else if (red == 5 && blue == 0 || red == 4 && blue == 1) {
            System.out.println("恭喜您中奖啦，四等奖！奖金200元！");
        } else if (red == 4 && blue == 0 || red == 3 && blue == 1 || red == 2 && blue == 1) {
            System.out.println("恭喜您中奖啦，五等奖！奖金10元！");
        } else if (red == 1 && blue == 1 || red == 0 && blue == 1) {
            System.out.println("恭喜您中奖啦，六等奖！奖金5元！");
        } else {
            System.out.println("啊没中奖，运气不太好呢，再接再厉啊！");
        }
    }
}

• 本次案例中是如何去统计红球的命中数量的？
  • 遍历用户的每个选号，然后遍历中奖号码的数组。
  • 看当前选号是否在中奖号码中存在，存在则命中数量加1。

---

【参考内容】：

• java判断字符串是否相等的方法（==或equals方法）
• 报错：ArrayIndexOutOfBoundsException数组下标越界异常
• 警告：String concatenation '+=' in loop
  1. JAVA不建议在for循环中使用”+”进行字符串拼接,而是建议使用StringBuilder的append方法
  2. 在循环足够次数很大的情况下，可能会浪费内存
• 被private static修饰的属性仅仅可以被静态方法调用，但是只能被本类中的方法（可以是非静态的）调用，在外部创建这个类的对象或者直接使用这个类访问都是非法的。被public static修饰的属性除了可以被静态方法和非静态调用之外，还可以直接被类名和外部创建的对象调用。