Java - day6 - 案例

案例一：飞机票

实例：

import java.util.Scanner;
public class 飞机票 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("机票原价：");
        double money = sc.nextDouble();

        System.out.println("机票月份：");
        int month = sc.nextInt();

        System.out.println("仓位类型：");
        String type = sc.next();

        //调用方法，统计结果
        System.out.println("优惠后的价格：" +calc(money,month,type));
    }

    public static double calc(double money,int month,String type) {
        //旺季
        if (month >=5 && month <=10){
            switch ( type){
                case "头等舱":
                money *=0.9;
                break;
                case "经济舱":
                    money *=0.85;
                    break;
                default:
                    System.out.println("数据有误");
                    money = -1;
            }
        }
        else if (month ==11 || month == 12 || month >= 1 && month <=4){
            //淡季
            switch ( type){
                case "头等舱":
                    money *=0.7;
                    break;
                case "经济舱":
                    money *=0.65;
                    break;
                default:
                    System.out.println("数据有误");
                    money = -1;
            }
        }
        else {
            System.out.println("数据有误");
            money = -1;
        }
        return money; //最终的价格
    }
}

回顾：

遇到判断值匹配的时选择什么结构实现?

• 使用switch分支结构实现。

遇到判断区间范围的时候选择什么结构实现?

• 使用if分支结构实现。

案例二：找素数

实例：

public class 找素数 {
    public static void main(String[] args) {
        //定义一个循环,找到101-200之间的全部数据
        for (int i = 101; i < 200; i++) {
            //信号位：标记
            boolean flag =true; //默认其为素数

            //遍历判断是否为素数
            for (int j = 2; j < i/2; j++) {
                if (i % j == 0){
                    flag = false;
                    break;
                }
            }
            if (flag){
                //是素数则输出
                System.out.println(i + "\t");
            }
        }
    }
}

案例三：开发验证码

实例：

import java.util.Random;
public class 开发验证码 {
    public static void main(String[] args) {
        //调用
        String code = crateCode(5);
        System.out.println("随机验证码："+code);
    }

    //定义一个方法返回一个随机验证码:是否需要返回值类型申明? String是否需要申明形参: int n
    public static String crateCode(int n) {
        //定义一个字符串记录生成的随机字符
        String code = "";
        Random r = new Random();

        //定义一个for循环,循环n次,依次生成随机字符
        for (int i = 0; i < n; i++) {
            int type = r.nextInt(3);
            switch (type){
                case 0://大写字符
                    char ch = (char)(r.nextInt(26)+ 65);
                    code +=ch;
                    break;
                case 1: //小写字符
                    char ch1 = (char)(r.nextInt(26)+ 97);
                    code +=ch1;
                    break;
                case 2:  //数字字符
                    code += r.nextInt(10);
                    break;
            }
        }
        return  code;
    }
}

回顾：

随机验证码的核心实现逻辑是如何进行的?

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

案例四：数组元素的复制

实例：

public class 数组元素的复制 {
    public static void main(String[] args) {
        int[] arr1 = {10,58,29};
        int[] arr2 = new int[arr1.length];

        copy(arr1,arr2);
        printArray(arr1);
        printArray(arr2);
    }

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print( i == arr.length -1 ? arr[i] : arr[i] + ",");
        }
        System.out.print("]");
    }

    public static void copy(int[] arr1,int[] arr2) {
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
    }
}

回顾：

数组的拷贝是什么意思?

• 需要创建新数组，把原来数组的元素赋值过来。

案例五：评委打分

实例：

import java.util.Scanner;

public class 评委打分 {
    public static void main(String[] args) {
        //定义动态数组
        int[] scores = new int[6];

        //录入分数
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            System.out.println("输入第" +(i+1) +"个评委的打分");
            int score = sc.nextInt();
            scores[i] = score;
        }

        //遍历，找出最大值，最小值和总分
        int max =scores[0];
        int min =scores[0];
        int sum = 0;
        
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] > max ){
                //替换最大值变量存储的数据
                max = scores[i];
            }

        if (scores[i] < min ){
            //替换最小值变量存储的数据
            min = scores[i];
        }

        sum += scores[i];  //总分
        }
        System.out.println("最高分：" + max);
        System.out.println("最低分：" + min);

        //平均分
        double result = (sum - max + min )* 1.0 /(scores.length -2);
        System.out.println("最终得分：" + result);
    }
}

回顾：

如何实现评委打分案例?

• 定义一个动态初始化的数组用于存储分数数据。
• 定义三个变量用于保存最大值、最小值和总和。
• 遍历数组中的每个元素，依次进行统计。

案例六：数字加密

实例：

/**
 需求：某系统的数字密码，比如1983，采用加密方式进行传输，规则如下：先得到每位数，
 然后每位数都加上5再对10求余，最后将所有数字反转，得到一串新数。

 */
public class 数字加密2 {
    public static void main(String[] args) {
        // 1、定义一个数组存储需要加密的数据
        int[] arr = new int[]{1, 9, 8, 3};

        // 2、遍历数组中的每个数据，按照规则进行修改
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }

        // 3、把数组中的元素进行反转操作。
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            // 交换 i 和 j位置处的值，即可反转
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }

        // 4、遍历数组中的每个元素输出即可
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
}

回顾：

本次案例中是如何完成数组元素的反转的?

• 定义2个变量分别占数组的首尾位置。
• 一个变量往前走，一个变量往后走，同步交换双方位置处的值。

案例七：数字加密

实例：

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

/**
 需求：双色球模拟
 */
public class 双色球 {
    public static void main(String[] args) {
        // 1、随机6个红球号码（1-33，不能重复），随机一个蓝球号码（1-16），可以采用数组装起来作为中奖号码
        int[] luckNumbers = createLuckNumber();
        // printArray(luckNumbers);

        // 2、录入用户选中的号码
        int[] userNumbers = userInputNumbers();

        // 3、判断中奖情况
        judge(luckNumbers, userNumbers);

    }

    public static void judge(int[] luckNumbers, int[] userNumbers ){
        // 判断是否中奖了。
        // luckNumbers = [12, 23, 8, 16, 15, 32,   9]
        // userNumbers = [23, 13, 18, 6, 8, 33,   10]
        // 1、定义2个变量分别存储红球命中的个数，以及蓝球命中的个数。
        int redHitNumbers = 0;
        int blueHitNumbers = 0;

        // 2、判断红球命中了几个，开始统计
        for (int i = 0; i < userNumbers.length - 1; i++) {
            for (int j = 0; j < luckNumbers.length - 1; j++) {
                // 每次找到了相等了，意味着当前号码命中了
                if(userNumbers[i] == luckNumbers[j]){
                    redHitNumbers ++ ;
                    break;
                }
            }
        }

        // 蓝球号码是否命中了
        blueHitNumbers = luckNumbers[6] == userNumbers[6] ? 1 : 0;

        System.out.println("中奖号码是："  );
        printArray(luckNumbers);
        System.out.println("您投注号码是："  );
        printArray(userNumbers);
        System.out.println("您命中了几个红球：" + redHitNumbers);
        System.out.println("您是否命中蓝球：" + ( blueHitNumbers == 1 ? "是": "否" ) );

        // 判断中奖情况了
        if(blueHitNumbers == 1 && redHitNumbers < 3){
            System.out.println("恭喜您，中了5元小奖！");
        }else if(blueHitNumbers == 1 && redHitNumbers == 3
                || blueHitNumbers == 0 && redHitNumbers == 4){
            System.out.println("恭喜您，中了10元小奖！");
        }else if(blueHitNumbers == 1 && redHitNumbers == 4
                || blueHitNumbers == 0 && redHitNumbers == 5){
            System.out.println("恭喜您，中了200元！");
        }else if(blueHitNumbers == 1 && redHitNumbers == 5){
            System.out.println("恭喜您，中了3000元大奖！");
        }else if(blueHitNumbers == 0 && redHitNumbers == 6){
            System.out.println("恭喜您，中了500万超级大奖！");
        }else if(blueHitNumbers == 1 && redHitNumbers == 6){
            System.out.println("恭喜您，中了1000万巨奖！可以开始享受人生，诗和远方！！");
        }else {
            System.out.println("感谢您为福利事业做出的突出贡献！！");
        }
    }

    public static int[] userInputNumbers(){
        // a、动态初始化一个数组，长度为7
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < numbers.length - 1; i++) {
            System.out.println("请您输入第"+(i + 1)+"个红球号码（1-33、不重复）：");
            int data = sc.nextInt();
            numbers[i] = data;
        }

        // b、录入一个蓝球号码
        System.out.println("请您输入一个蓝球号码（1-16）：");
        int data = sc.nextInt();
        numbers[numbers.length - 1] = data;

        return numbers;
    }

    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static int[] createLuckNumber(){
        // a、定义一个动态初始化的数组，存储7个数字
        int[] numbers = new int[7];  // [12, 23, 0, 0, 0, 0, | 0]
        //                                   i
        // b、遍历数组，为每个位置生成对应的号码。(注意：遍历前6个位置，生成6个不重复的红球号码，范围是1-33)
        Random r = new Random();
        for (int i = 0; i < numbers.length - 1; i++) {
            // 为当前位置找出一个不重复的1-33之间的数字
            while (true) {
                int data = r.nextInt(33) + 1; // 1-33 ====>  (0-32) + 1

                // c、注意：必须判断当前随机的这个号码之前是否出现过，出现过要重新随机一个，直到不重复为止，才可以存入数组中去。
                // 定义一个flag变量，默认认为data是没有重复的
                boolean flag = true;
                for (int j = 0; j < i; j++) {
                    if(numbers[j] == data) {
                        // data当前这个数据之前出现过，不能用
                        flag = false;
                        break;
                    }
                }

                if(flag) {
                    // data这个数据之前没有出现过，可以使用了
                    numbers[i] = data;
                    break;
                }
            }
        }
        // d、为第7个位置生成一个1-16的号码作为蓝球号码
        numbers[numbers.length - 1] = r.nextInt(16) + 1;
        return numbers;
    }
}

回顾：

本次案例中是如何去统计红球的命中数量的?

• 遍历用户的每个选号，然后遍历中奖号码的数组。
• 看当前选号是否在中奖号码中存在，存在则命中数量加1。