20天学会Java-专题课编程案例

案例一:买飞机票

需求
用户购买机票时，机票原价会按照淡季、旺季，头等舱还是经济舱的情况进行相应的优惠，优惠方案如下: 5-10月为旺季，头等舱9折，经济舱8.5折; 11月到来年4月为淡季， 头等舱7折，经济舱6.5折，请开发程序计算出用户当前机票的优惠价。
分析:
●方法是否 需要接收数据?  需要接收机票原价、当前月份、舱位类型;
●方法是否 需要返回数据?  需要返回计算出的机票优惠价。
● 方法内部:先使用if判断月份是旺季还是淡季，然后使用switch分支判断是头等舱还是经济舱

package com.heima.ticket;

public class BuyTicket {
    public static void main(String[] args) {
        System.out.println(Buythicket(200, 12, "经济舱"));
    }
    public static double Buythicket(double price,int month,String type) {
        if (month >=5 && month <= 10){
            switch(type){
                case "头等舱":
                    price *=0.9;
                    break;
                case "经济舱":
                    price *=0.85;
                    break;
            }
        }else{
            switch(type){
                case "头等舱":
                    price *=0.7;
                    break;
                case "经济舱":
                    price *=0.65;
                    break;
            }
        }
        return price;
    }
}

1、遇到需要通过判断数据在哪个区间，来决定执行哪个业务，应该用什么实现?
●应该使用if分支结构实现。
2、遇到需要通过判断数据匹配哪个值，来决定执行哪个业务，应该用什么实现?
●应该使用switch分 支结构实现。

案例二:开发验证码

需求
开发一个程序，可以生成指定位数的验证码，每位可以是数字、大小写字母。
分析:
①方法是否需要接收数据?需要接收一 个整数,控制生成验证码的位数。
②方法是否需要返回数据?
需要返回生成的验证码。
③方法内部的业务:使用for循环依次生成每位随机字符，并使用一个
String类的变量把每个字符连接起来，最后返回该变量即可。

import java.util.Random;

public class CreateCode {
    public static void main(String[] args) {
        System.out.println(CreateCode(6));
    }
    public static String CreateCode(int lon) {
        Random r =new Random();
        String code = "";
        for (int i = 1; i <= lon; i++) {
            int type = r.nextInt(3);//0:数字 1：大写字母  2：小写字母
            switch (type){
                case 0:
                    code += r.nextInt(10);
                    break;
                case 1:
                    char ch1 = (char) (r.nextInt(26) + 65);//alt+enter快速转字符类型
                    code += ch1;
                    break;
                case 2:
                    char ch2 = (char) (r.nextInt(26) + 97);//alt+enter快速转字符类型
                    code += ch2;
                    break;
            }
        }
        return code;

    }
}

随机验证码的核心实现逻辑是如何进行的?
①定义一个for循环，循环5次。
②随机生成0|1|2的数据，依次代表当前要生成的字符是:数字、大写字母、小写字母。
③把0、1、2交给switch生成对应类型的随机字符。
④在循环外定义-一个String类型的变量用来连接生成的随机字符。
⑤循环结束后，返回String类型的变量即是生成的随机验证码。

案例三:评委打分

需求
在唱歌比赛中，可能有多名评委要给选手打分，分数是[0 - 100]之间的整数。选手最后得分为:去掉最高分、最低分后剩余分数的平均分，请编写程序能够录入多名评委的分数，并算出选手的最终得分。
分析:
1.方法是否需要接收数据进行处理?     需要接收评委的人数。
2.方法是否需要返回数据?      需要返回计算出的选手最终得分
3.方法内部的业务:定义数组，录入评委的分数存入到数组中去，接着，我们就需要遍历数组中的分数，计算出总分，并找出最高分,最低分、最后按照这些数据算出选手最终得分并返回即可。

package com.heima.ticket;

import java.util.Scanner;

public class score {
    public static void main(String[] args) {
        System.out.println(score(6));
    }
    public static double score(int n) {
        Scanner sc = new Scanner(System.in);
        double score =0;
        int[] sco = new int[n];
        for (int i = 0; i < n; i++) {
            System.out.println("请输入"+ (i+1) +"个评委的分数：");
            sco[i] = sc.nextInt();
        }
        int sum = 0;
        int max = sco[0];
        int min = sco[0];
        for (int i = 0; i < sco.length; i++) {
            int scor = sco[i];
            sum += scor;
            if (scor > max){
                max =scor;
            }
            if (scor < min){
                min =scor;
            }
        }
        score = 1.0*(sum -max -min)/(n-2);//1.0*注意要放在前面，不然没效果
        return score;
    }
}

如何实现评委打分案例?
①定义一个动态初始化的数组，用于录入评委打分。
②提前定义三个变量用来记住数组中的最大值、最小值、总和。
③遍历数组中的每个数据，依次找出最大值、最小值、总和。
④遍历结束后，按照计算规则算出选手的最终得分，并返回即可。

案例四:数字加密

需求
某系统的数字密码是一个四位数，如1983, 为了安全，需要加密后再传输，加密规则是:对密码中的每位数,都加5 ,再对10求余，最后将所有数字顺序反转，得到一串加密后的新数，请设计出满足本需求的加密程序!

分析:
1.方法是否需要接收数据进行处理?      需要接收四位数字密码，进行加密处理。
2.方法是否需要返回数据?                    需要返回加密后的结果。
3.方法内部的业务:将四位数字密码拆分成一个一个的数字，存入到数组中去,遍历数组中的每个数字,按照题目需求进行加密!最后，再把加密后的数字拼接起来返回即可!

public class code {
    public static void main(String[] args) {
        System.out.println(encrypt(1983));
    }
    public static String encrypt(int number) {
        int[] numbers = split(number);
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = (numbers[i] + 5) %10;
        }
        reverse(numbers);
        String data = "";
        for (int i = 0; i < numbers.length; i++) {
            data += numbers[i];
        }
        return data;
    }

    private static void reverse(int[] numbers) {
        int temp;
        for (int i = 0, j = numbers.length-1; i < j; i++,j--) {
            temp = numbers[i];
            numbers[i] = numbers[j];
            numbers[j] = temp;
        }
    }

    private static int[] split(int number) {
        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;
    }
}

1、回顾数组元素的反转、交换是如何完成的?
●反转数组，就是对数组中的元素,按照前后位置，依次交换数据。
2、如果一个方法里要做的事比较多，我们在开发中一般会怎么做?
●一般会把多个事拆成多个方法去完成，也就是独立功能独立成一个方法。

案例五:数组拷贝

需求
请把一个整型数组，例如存了数据: 11, 22, 33,拷贝成一个一模一样的新数组出来。
分析:
1.方法是否需要接收数据进行处理?        需要接收一个整型数组(原数组) 。
2.方法是否需要返回数据?                      需要返回一个新的、一模一 样的整型数组。
3.方法内部的业务:创建一个长度一样的整型数组做为新数组，并把原数组的元素对应位置赋值给新数组，最终返回新数组即可。

public class copy {
    public static void main(String[] args) {
        int[] arr1 = {20,21,23};
        int[] arr2 = copyArray(arr1);
        System.out.println(arr1);
        System.out.println(arr2);//可以看出地址不一致
        printArray(arr2);

    }

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

    private static int[] copyArray(int[] arr) {
        int[] arr2 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] =arr[i];
        }
        return arr2;
    }
}

数组拷贝地址是不一样的两个数组

案例六:抢红包

需求
一个大V直播时发起了抢红包活动，分别有: 9、666、188、 520、99999五个红包。请模拟粉丝来抽奖，按照先来先得,随机抽取，抽完即止，注意:一个红包只能被抽一次，先抽或后抽哪一个红包是随机的，示例如下(不一定是下面的顺序)

分析:
1.方法是否需要接收数据进行处理? 需要接收一个数组，里面是5个金额，表示5个红包
2.方法是否需要返回数据?不需要
3.方法内部完成本需求的第1种方案:写个for循 环控制抽奖5次,每次抽奖,都从数组中随机找出一个金额，如果该金额不是0,则代表抽中,接着用0替换该位置处的金额，然后继续下一个粉丝的抽奖;如果抽中的金额发现是0,代表该位置处的红包之前被别人抽走了,则从新从数组中随机找出一个金额，继续判断!直至抽中的金额不是0!

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

public class redpack {
    public static void main(String[] args) {
        int[] red ={9,99,999,9999};
        redpack( red );
    }
    public static void redpack(int[] redPack) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        for (int i = 0; i < redPack.length; i++) {
            System.out.println("请按任意键抽奖");
            sc.next();//等待用户输入内容，按了回车才往下走的。
            while (true) {
                int index = r.nextInt(redPack.length);
                if  (redPack[index]!=0){
                    System.out.println("您中了" + redPack[index]);
                    redPack[index] = 0;
                    break;
                }
            }
        }             
    }
}

抢红包的实现方案有几种，哪种方式可能更好一些?
●第1种: 每次抽奖都从数组中，随机找出一个金额，如果该金额不是0,就输出该金额,然后用0替换该位置处的金额;如果该位置就是0，则重复上一步操作!
●第2种:打乱奖金的顺序，再依次发给粉丝
遍历数组中的每个位置，每遍历到一个位置，都随机一个索引值出来,让当前位置与该索引位置处的数据进行交换。

案例七:找素数

1、判断101-200之间有多少个素数，并输出所有素数。
说明:除了1和它本身以外，不能被其他正整数整除，就叫素数。
比如: 3、7就是素数,而9、21等等不是素数。
分析:
1.方法是否需要接收数据进行处理?  需要接收101以及200,以便找该区间中的素数。
2.方法是否需要返回数据?                需要返回找到的素数个数。
3.方法内部的实现逻辑:使用for循环来产生如101到200之间的每个数;每拿到一个数,判断该数是否是素数;判断规则是:
从2开始遍历到该数的一半的数据，看是否有数据可以整除它，有则不是素数，没有则是素数;根据判定的结果来决定是否输出这个数据(是素数则输出) ;最后还需要统计素数的个数并返回。

public class search {
    public static void main(String[] args) {
        System.out.println("素数个数为" + search(101, 200));
    }
    public  static  int search(int start ,int end ){
        int n = 0;
        for (int i = start; i <=end; i++) {

            //信号位思想
            boolean flag = true;//假设的意思:默认认为当前i记住的数据是素数。

            for(int j = 2; j <= i/2; j++){
                if(i % j ==0){
                    flag = false;
                    break;
                }
            }
            if (flag){
                System.out.println(i);
                n +=1;
            }
        }
        return n;
    }
}

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

案例7.1、打印乘法表

计算机只能按行打

public class multipleList {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            int k = i;
            for (int j = 1; j <= k; j++) {
                    System.out.print(j + "x" + i + "=" + i*j);
                System.out.print(" ");
            }
            System.out.println();
        }
    }
}

案例7.2、打印三角形

public static void main(String[] args) {
        int n = 10;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < n-i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < 1+ (2*(i-1)); k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

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

双色球业务介绍:

总体实现步骤分析:

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

public class shuangseqiu {
    public static void main(String[] args) {
        int[] userNumber = userSelectNumber();
        int[] luckNumber = createLuckNumber();
        judge(userNumber, luckNumber);
    }

    private static void judge(int[] userNumber, int[] luckNumber) {
        int redNumber = 0;
        int greenNumber = 0;
        for (int i = 0; i < userNumber.length-1; i++) {
            if(userNumber[i] == luckNumber[i]){
                redNumber++;
            }else {
                continue;
            }
        }
        if(userNumber[6] == luckNumber[6]){
            greenNumber++;
        }
        if (greenNumber==1){
            switch (redNumber){
                case 6:
                    System.out.println("您中了最高1000万");
                case 5:
                    System.out.println("您中了3000");
                case 4:
                    System.out.println("您中了200");
                case 3:
                    System.out.println("您中了10");
                case 2:
                    System.out.println("您中了10");
                case 1:
                    System.out.println("您中了5");
                case 0:
                    System.out.println("您未中奖");
            }
        }else{
            switch (redNumber){
                case 6:
                    System.out.println("您中了最高500万");
                case 5:
                    System.out.println("您中了200");
                case 4:
                    System.out.println("您中了10");
                case 3:
                    System.out.println("您未中奖");
                case 2:
                    System.out.println("您未中奖");
                case 1:
                    System.out.println("您未中奖");
                case 0:
                    System.out.println("您未中奖");
            }
        }

    }

    private static int[] createLuckNumber() {
        Random r = new Random();
        int[] luckNumber = new int[7];
        for (int i = 0; i < 6; i++) {
            int number = r.nextInt(32) + 1;
            if (exist(luckNumber, number)) {
                System.out.println("您输入的号码重复了");
            }else{
                luckNumber[i] = number;
                break;
            }
        }
        int number = r.nextInt(15) +1;
        luckNumber[6] = number;
        return luckNumber;
    }

    private static int[] userSelectNumber() {
        Scanner sc = new Scanner(System.in);
        int[] userNumber = new int[7];
        for (int i = 0; i < 6; i++) {
            while (true) {
                System.out.println("请给出第" + (i+1) + "的红球号码");
                int number = sc.nextInt();
                if (number < 1 || number > 33){
                    System.out.println("您输入的号码有误");
                }else {
                    if (exist(userNumber, number)) {
                        System.out.println("您输入的号码重复了");
                    }else{
                        userNumber[i] = number;
                        break;
                    }
                }
            }
        }
        while (true) {
            System.out.println("请给出绿球号码");
            int number = sc.nextInt();
            if (number < 1 || number > 16){
                System.out.println("您输入的号码有误");
            }else {
                userNumber[6] = number;
                break;
            }
        }
        return userNumber;
    }
    private static boolean exist(int[] numbers,int number) {
        boolean bool = false;
        for (int i = 0; i < numbers.length-1; i++) {
            if(numbers[i] == number){
                bool =true;
                break;
            }else{
                bool = false;
            }
        }
        return bool;
    }
}

本次案例中是如何去统计用户投注的红球的命中数量的?
●遍历用户选择的每个红球号码，每遍历一一个红球号码时，都去遍历中奖号码数组中的全部红球号码，看当前选的红球号码是否在中奖号码中存在，存在则红球命中数量加1。