Java编程案例

案例一：买飞机票

public class Test1 {
    public static void main(String[] args) {
        // 目标：完成买飞机票的案例。
        double price = calculate(1000, 11, "头等舱");
        System.out.println("优惠价是：" + price);
    }

    public static double calculate(double price,int month,String type){
        // 1、判断当前月份是淡季还是旺季
        if(month >= 5 && month <= 10) {
            // 旺季
            // 2、判断仓位类型。
            switch (type){
                case "头等舱":
                    price *= 0.9; // price = price * 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
            }
        }else {
            // 淡季
            switch (type){
                case "头等舱":
                    price *= 0.7; // price = price * 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
            }
        }
        return price;
    }
}

案例二：开发验证码

public class Test2 {
    public static void main(String[] args) {
        // 目标：完成生成随机验证码。
        System.out.println(createCode(8));
    }

    public static String createCode(int n){
        //1)先按照方法接收的验证码位数n,循环n次
        Random r = new Random();
        //3)定义一个String类型的变量用于记住产生的每位随机字符
        String code = "";
        for (int i = 1; i <= n; i++) {
            // i = 1 2 3 4 5
            //2)每次循环，产生一个字符，可以是数字字符、或者大小写字母字符
            // 思路：随机一个0 1 2之间的数字出来，0代表随机一个数字字符，1、2代表随机大写字母，小写字母。
            int type = r.nextInt(3); // 0 1 2
            switch (type) {
                case 0:
                    // 随机一个数字字符
                    code += r.nextInt(10); // 0 - 9  code = code + 8
                    break;
                case 1:
                    // 随机一个大写字符 A 65   Z 65+25    (0 - 25) + 65
                    char ch1 = (char) (r.nextInt(26) + 65);
                    code += ch1;
                    break;
                case 2:
                    // 随机一个小写字符 a 97   z 97+25    (0 - 25) + 97
                    char ch2 = (char) (r.nextInt(26) + 97);
                    code += ch2;
                    break;
            }
        }
        return code;
    }
}

案例三：评委打分

public class Test3 {
    public static void main(String[] args) {
        // 目标：完成评委打分案例。
        System.out.println("当前选手得分是：" + getAverageScore(6));
    }

    public static double getAverageScore(int n){
        // 1、定义一个动态初始化的数组，负责后期存入评委的打分
        int[] scores = new int[n]; // 6
        // scores = [0, 0, 0, 0, 0, 0]

        // 2、遍历数组的每个位置，依次录入评委的分数
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            // i = 0 1 2 3 4 5
            System.out.println("请您录入第"+ (i + 1) +"个评委的分数：");
            int score = sc.nextInt();
            scores[i] = score;
        }

        // 3、从数组中计算出总分，找出最高分，最低分。
        int sum = 0; // 求总分用的变量
        int max = scores[0]; // 求最大值的
        int min = scores[0]; // 求最小值的。

        // 遍历数组找出这些数据的。
        for (int i = 0; i < scores.length; i++) {
            // i = 0 1 2 3 4 5
            int score = scores[i];
            // 求和
            sum += score;
            // 求最大值
            if(score > max){
                max = score;
            }
            // 求最小值
            if(score < min){
                min = score;
            }
        }
        // 4、计算出平均分并返回
        return 1.0 * (sum - min - max) / (number - 2);
    }
}

案例四：数字加密

public class Test4 {
    public static void main(String[] args) {
        // 目标：完成数字加密程序的开发。
        System.out.println("加密后的结果是：" + encrypt(8346));
    }

    public static String encrypt(int number){
        // number = 1983
        // 1、把这个密码拆分成一个一个的数字，才可以对其进行加密啊。
        int[] numbers = split(number);
        // numbers = [1, 9, 8, 3]

        // 2、遍历这个数组中的每个数字，对其进行加密处理。
        for (int i = 0; i < numbers.length; i++) {
            // i = 0 1 2 3
            numbers[i] = (numbers[i] + 5) % 10;
        }
        // numbers = [6, 4, 3, 8]

        // 3、对数组反转，把对数组进行反转的操作交给一个独立的方法来完成
        reverse(numbers);
        // numbers = [8, 3, 4, 6]

        // 4、把这些加密的数字拼接起来做为加密后的结果返回即可。
        String data = "";
        for (int i = 0; i < numbers.length; i++) {
            data += numbers[i];
        }
        return data;
    }

    public static void reverse(int[] numbers) {
        // 反转数组的
        // numbers = [6, 4, 3, 8]
        //            i        j
        for (int i = 0, j = numbers.length - 1; i < j; i++,j--) {
            // 交换i和j位置处的值。
            // 1、把后一个位置处的值交给一个临时变量先存起来
            int temp = numbers[j];
            // 2、把前一个位置处的值赋值给后一个位置处
            numbers[j] = numbers[i];
            // 3、把后一个位置处原来的值（由临时变量记住着）赋值给前一个位置
            numbers[i] = temp;
        }
    }

    public static int[] split(int number) {
        // number = 1983
        int[] numbers = new int[4];
        numbers[0] = number / 1000;
        numbers[1] = (number / 100) % 10;
        numbers[2] = (number / 10) % 10;
        numbers[3] = number % 10;
        return numbers;
    }
}

案例五：数组拷贝

public class Test5 {
    public static void main(String[] args) {
        // 目标：掌握数组拷贝。
        int[] arr = {11, 22, 33};
        int[] arr2 = copy(arr);
        printArray(arr2);

        // 注意：这个不是拷贝数组，叫把数组变量赋值给另一个数组变量。
        //        int[] arr3 = arr;
        //        arr3[1] = 666;
        //        System.out.println(arr[1]);

        arr2[1] = 666;
        System.out.println(arr[1]);
    }

    public static int[] copy(int[] arr){
        // arr = [11, 22, 33]
        //        0    1   2

        // 1、创建一个长度一样的整型数组出来。
        int[] arr2 = new int[arr.length];
        // arr2 = [0, 0, 0]
        //         0  1  2

        // 2、把原数组的元素值对应位置赋值给新数组。
        for (int i = 0; i < arr.length; i++) {
            // i = 0 1 2
            arr2[i] = arr[i];
        }

        return 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.println("]");
    }
}

案例六：抢红包

public class Test6 {
    public static void main(String[] args) {
        int[] moneys = {100,999,50,520,1314};
        start(moneys);
    }
    //开始抽奖
    public static void start(int[] moneys){
        //1)首先，写一个循环，循环次数为数组的长度
        for (int i = 0; i < moneys.length; i++) {
            //2)每次循环，键盘录入，提示"用户录入任意键抽奖："
            while (true){
                Scanner sc = new Scanner(System.in);
                System.out.print("用户录入任意键抽奖：");
                String msg = sc.next();
                //3)随机从数组中产生一个索引，获取索引位置的元素，这个元素就表示抽的红包
                Random r = new Random();
                int index = r.nextInt(moneys.length);
                int money = moneys[index];
                if(money!=0){
                    //如果值不为0，则打印如："恭喜您，您抽中了520元"
                    System.out.println("恭喜您，您抽中了"+money+"元");
                    moneys[index] = 0;
                    break;
                }else {
                    //如果值为0，则说明这个红包被抽过，重新循环到第2步，重新抽奖
                    //此时这一次抽奖机会被浪费掉了，可以把控制循环的次数自减一下
                    i--;
                }
            }
        }
    }
}

案例七：找素数

public class Test7 {
    public static void main(String[] args) {
        // 目标：完成找素数。
        System.out.println("当前素数的个数是：" + search(101, 200));
    }

    public static int search(int start, int end){
        int count = 0;
        // start = 101   end = 200
        // 1、定义一个for循环找到101到200之间的每个数据
        for (int i = start; i <= end ; i++) {
            // i = 101 102 103 ... 199 200

            // 信号位思想
            boolean flag = true; // 假设的意思：默认当前i记住的数据是素数。
            // 2、判断当前i记住的这个数据是否是素数。
            for (int j = 2; j <= i / 2; j++) {
                if(i % j == 0){
                    // i当前记住的这个数据不是素数了
                    flag = false;
                    break;
                }
            }
            // 3、根据判定的结果决定是否输出i当前记住的数据：是素数才输出展示。
            if(flag){
                System.out.println(i);
                count++;
            }
        }
        return count;
    }
}

案例八：模拟双色球[拓展案例]

第一个方法，让用户手动投注，产生一注双色球彩票

第二个方法，由系统随机产生一注双色球彩票开奖号码

第三个方法，判断传入两组号码，用于判断彩票的中奖情况

8.1 手动投注

/** 1、设计一个方法，用于让用户投注一组号码并返回（前6个是红球号码，最后1个是蓝球号码 ）*/
public static int[] userSelectNumbers(){
    // 2、创建一个整型数组，用于存储用户投注的7个号码（前6个是红球号码，最后1个是蓝球号码 ）
    int[] numbers =  new int[7];
    // numbers = [0, 0, 0, 0, 0, 0, 0]
    //            0  1  2  3  4  5  6

    Scanner sc = new Scanner(System.in);
    // 3、遍历前6个位置，让用户依次投注6个红球号码，存入
    for (int i = 0; i < numbers.length - 1; i++) {
        // i = 0 1 2 3 4 5

        while (true) {
            // 4、开始让用户为当前位置投注一个红球号码（1-33之间，不能重复）
            System.out.println("请您输入第" + (i + 1) + "个红球号码（1-33之间，不能重复）：");
            int number = sc.nextInt();

            // 5、先判断用户输入的红球号码是否在1-33之间
            if(number < 1 || number > 33){
                System.out.println("对不起，您输入的红球号码不在1-33之间，请确认！");
            }else {
                // 号码是在1-33之间了，接着还要继续判断这个号码是否重复，不重复才可以使用。
                if(exist(numbers, number)){
                    // number当前这个红球号码是重复了。
                    System.out.println("对不起，您当前输入的红球号码前面选择过，重复了，请确认！");
                }else {
                    // number记住的这个号码没有重复了，就可以使用了。
                    numbers[i] = number;
                    break; // 结束当次投注，结束了当前死循环。
                }
            }
        }
    }

    // 6、投注最后一个蓝球号码。
    while (true) {
        System.out.println("请您输入最后1个蓝球号码（1-16）：");
        int number = sc.nextInt();
        if(number < 1 || number > 16){
            System.out.println("对不起，您输入的蓝球号码范围不对！");
        }else {
            numbers[6] = number;
            break; // 蓝球号码录入成功，结束死循环
        }
    }

    return numbers;
}

每键盘录入一个号码，需要判断这个号码在数组中是否存在，存在返回true；不存在返回false

private static boolean exist(int[] numbers, int number) {
    // 需求：判断number这个数字是否在numbers数组中存在。
    // numbers = [12, 25, 18, 0, 0, 0, 0]
    // number = 12
    for (int i = 0; i < numbers.length; i++) {
        if(numbers[i] == 0){
            break;
        }
        if(numbers[i] == number){
            return true;
        }
    }
    return false;
}

为了打印一注彩票的号码（数组中的元素），把打印数组中的元素也写成方法。

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.println("]");
}

在main方法中测试，运行看能不能产生一注彩票号码

public class Test8 {
    public static void main(String[] args) {
        // 目标：完成双色球系统的开发。
        int[] userNumbers = userSelectNumbers();
        System.out.println("您投注的号码：");
        printArray(userNumbers);
    }
}

8.2 随机开奖号码

/** 2、设计一个方法：随机一组中奖号码出来（6个红球号码，1个蓝球号码 ）*/
public static int[] createLuckNumbers(){
    // 1、创建一个整型数组，用于存储这7个号码
    int[] numbers = new int[7];

    Random r  = new Random();
    // 2、遍历前6个位置处，依次随机一个红球号码存入（1-33 不重复）
    for (int i = 0; i < numbers.length - 1; i++) {
        // i = 0 1 2 3 4 5
        while (true) {
            // 3、为当前这个位置随机一个红球号码出来存入。
            //1 - 33 ==> -1 ===> (0 , 32) + 1
            int number = r.nextInt(33) + 1;

            // 4、判断这个号码是否之前出现过（红球号码不能重复）。
            if(!exist(numbers, number)){
                // number不重复。
                numbers[i] = number;
                //结束死循环，代表找到了当前这个位置的一个不重复的红球号码了。
                break; 
            }
        }
    }

    // 3、录入一个蓝球号码。 1-16
    numbers[6] = r.nextInt(16) + 1;
    return numbers;
}

8.3 判断是否中奖

/** 3、设计一个方法，用于判断用户的中奖情况 */
public static void judge(int[] userNumbers,int[] luckNumbers){
    // userNumbers = [12, 14, 16, 18, 23, 26, 8]
    // luckNumbers = [16, 17, 18, 19, 26, 32, 8]

    // 2、分别定义2个变量用于记住红球命中了几个以及蓝球命中了几个
    int redCount = 0;
    int blueCount = 0;

    // 先判断红球命中的数量。
    // 遍历用户投注的号码的前6个红球
    for (int i = 0; i < userNumbers.length - 1; i++) {
        // userNumbers[i]
        // 开始遍历中奖号码的前6个红球号码，看用户当前选择的这个号码是否命中了
        for (int j = 0; j < luckNumbers.length - 1; j++) {
            if(userNumbers[i] == luckNumbers[j]){
                redCount++;
                break;
            }
        }
    }

    // 3、判断蓝球是否命中了
    blueCount = userNumbers[6] == luckNumbers[6] ? 1 : 0;

    System.out.println("您命中的红球数量是：" + redCount);
    System.out.println("您命中的蓝球数量是：" + blueCount);

    // 4、判断中奖详情，并输出结果
    if(redCount == 6 && blueCount == 1){
        System.out.println("恭喜您，中奖1000万，可以开始享受人生了~~~");
    }else if(redCount == 6 && blueCount == 0){
        System.out.println("恭喜您，中奖500万，可以稍微开始享受人生了~~~");
    }else if(redCount == 5 && blueCount == 1){
        System.out.println("恭喜您，中奖3000元，可以出去吃顿小龙虾了~");
    }else if(redCount == 5 && blueCount == 0 || redCount == 4 && blueCount == 1){
        System.out.println("恭喜您，中了小奖：200元~");
    }else if(redCount == 4 && blueCount == 0 || redCount == 3 && blueCount == 1){
        System.out.println("中了10元~");
    }else if( redCount < 3 && blueCount == 1){
        System.out.println("中了5元~");
    }else {
        System.out.println("感谢您对福利事业做出的巨大贡献~~~");
    }
}

public class Test8 {
    public static void main(String[] args) {
        // 目标：完成双色球系统的开发。
        //用户投注
        int[] userNumbers = userSelectNumbers();
        System.out.println("您投注的号码：");
        printArray(userNumbers);
		
        //随机产生一个中奖号码
        int[] luckNumbers = createLuckNumbers();
        System.out.println("中奖的号码：");
        printArray(luckNumbers);

        //判断用户投注的号码是否中奖
        judge(userNumbers, luckNumbers);
    }
}