Java案例

案例1：买飞机票

需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。

机票最终优惠价格的计算方案如下:旺季(5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。

分析：键盘录入机票的原价，仓位类型，月份信息，调用方法返回机票最终的优惠价格。

方法内部应该先使用if分支判断月份是是旺季还是淡季，然后使用switch分支判断是头等舱还是经济舱。

package com.practice;

import java.util.Scanner;

public class Test01 {
    public static void main(String[] args) {
        //1.用户输入机票 月份 仓位
        Scanner sc=new Scanner(System.in);
        System.out.println("请你输入机票原价");
       double money= sc.nextDouble();
        System.out.println("请你输入月份：（1-12）：");
        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){
        //3.判断用户选择的信息情况
        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("对不起，你输入的月份有问题");
            return -1;
        }
        return money;
    }
}

找素数：

需求：判断101-200之间有多少个素效，并输出所有素数。‘

分析：101-200之间的数据可以采用循环依次拿到;每拿到一个数，判断该数是否是素数。

从2开始遍历到该数的一半的数据，看是否有数据可以整除它，有则不是素数，没有则是素数。

package com.practice;

public class Test02 {
    public static void main(String[] args) {
        //定义一个循环
        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.print(i+"\t");
            }
        }
    }
}

开发验证码：

定义方法实现随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母

分析：（1）定义一个方法，生成验证码返回:方法参数是位数、方法的返回值类型是String。

（2）在方法内部使用for循环生成指定位数的随机字符，并连接起来。

（3）把连接好的随机字符作为一组验证码进行返回。

package com.practice;

import java.util.Random;

public class Test03 {
    public static void main(String[] args) {
        //5.调用获取验证码方法
        String code=creatCode(5);
        System.out.println("随机验证码"+code);

    }
    //1.定义一个方法
    public static String creatCode(int n){
        //定义一个字符串变量记录生成随机字符
        String code="";
        //2.定义一个for循环
        Random r=new Random();
        for (int i = 0; i <n ; i++) {
            //3.生成一个随机字符
            int type=r.nextInt(3);
            switch (type){
                case 0:
                    //大写字符(A 65-Z 65+25)(0-25)+65
                    char ch= (char) (r.nextInt(26)+65);
                    code+=ch;
                    break;
                case 1:
                    //小写字符(a 97-z 97+25)(0-25)+97
                    char ch1= (char) (r.nextInt(26)+97);
                    code+=ch1;
                    break;
                case 2:
                    //数字字符
                    code+=r.nextInt(10);//0-9
                    break;
            }
        }
        return code;
    }
}

数组元素的复制：

把一个数组中的元素复制到另一个新数组中去。

分析：

（1）需要动态初始化一个数组，长度与原数组一样。

（2）遍历原数组的每个元素，依次赋值给新数组。

（3）输出两个数组的内容。

package com.practice;

public class Test04 {
    public static void main(String[] args) {
        int arr1[]={11,22,55,66};
        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.println("}");
    }
    public static void copy(int arr1[],int arr2[]){
        //正式完成元素的复制
        for (int i = 0; i < arr1.length ; i++) {
            arr2[i]=arr1[i];
        }
    }
}

评委打分案例：

在唱歌比赛中，有6名评委给选手打分，分数范围是[0–100]之间的整数。选手的最后得分为:去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。

分析：（1）把6个评委的分数录入到程序中去---->使用数组

（2）遍历数组中每个数据，进行累加求和，并找出最高分、最低分。

（3）按照分数的计算规则算出平均分。

package com.practice;

import java.util.Scanner;

public class Test05 {
    public static void main(String[] args) {
        //1.定义一个动态初始化数组，用于后期录入6个评委分数
        int scores[]=new int[6];
        //2.录入6个评委分数
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < scores.length ; i++) {
            System.out.println("请你输入第"+(i+1)+"评委的分数:");
            int score=sc.nextInt();
            //3.把这个分数存入数组的对应位置处
            scores[i]=score;
        }
        //4.遍历数组中每个数据
        //int max=scores[0],min=scores[0],sum=0;
        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("最低分"+min);
        System.out.println("最高分"+max);
        //统计平均分
        double result=(sum-max-min)*1.0/ (scores.length-2);
        System.out.println("最终得分是："+result);
    }
}

数字加密：

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

分析：将每位数据存入到数组中去，遍历数组每位数据按照规则进行更改，把更改后的数据从新存入到数组中。

将数组的前后元素进行交换，数组中的最终元素就是加密后的结果。

package com.practice;

import java.util.Scanner;

public class Test06 {
    public static void main(String[] args) {
        //数据加密
        //1.定义一个数组存入需要加密的数据
        System.out.println("请你输入需要加密的数字个数：");
        Scanner sc=new Scanner(System.in);
        int length=sc.nextInt();
        int arr[]=new int[length];
        //2.录入需要加密的数字
        for (int i = 0; i < arr.length ; i++) {
            System.out.println("请你输入需要加密的第"+(i+1)+"个数字");
            int number=sc.nextInt();
            arr[i]=number;
        }
        //3.打印数组内容看一下
        printArray(arr);
        //4.加密//arr={1,9,8,3}
        for (int i = 0; i < arr.length ; i++) {
           arr[i] =(arr[i]+5)%10;
        }
        //5.反转 arr={6,4,3,8}
        for (int i = 0,j=arr.length-1; i < j; i++,j--) {
            int temp=arr[j];
            arr[j]=arr[i];
            arr[i]=temp;
        }
        printArray(arr);
    }
    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("}");
    }
}

模拟双色球：

双色球系统-业务分析、随机生成一组中奖号码

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

（1）中奖号码由6个红球和1个篮球组成(注意:6个红球要求不能重复)。

（2）可以定义方法用于返回一组中奖号码(7个数据)，返回的形式是一个整型数组。

（3）定义一个方法，该方法可以录入用户输入的6个红球和1个篮球号码

（4）该方法最终需要返回一个数组，数组中就是用户录入的号码（7位)。

（5）定义一个方法，可以接收中奖号码的数组，用户选号的数组。

（6）根据命中红球数和篮球数判断最终的中奖情况并输出详情和中奖金额。

package com.practice;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

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

public class Test07 {
    public static void main(String[] args) {
        //1.随机六个红球号码，随机一个蓝球号码
       int lucknumbers[]= creatlucknumber();
       //2.录入用户中奖情况
       int[] usernumbers=userinputnumbers();
       //3.判断中奖情况
        judge(lucknumbers,usernumbers);
    }
    public static void judge(int[] lucknumbers,int[] usernumbers){
        //判断是否中中奖
        //1.定义两个变量 分别存储红球命中个数和蓝球命中个数
        int rednumbers=0;
        int bluenumbers=0;
        //2.判断红球命中几个 开始统计
        for (int i = 0; i <usernumbers.length-1 ; i++) {
            for (int j = 0; j <lucknumbers.length-1 ; j++) {
                //每次找到相等 意味命中了
                if(usernumbers[i]==lucknumbers[i]){
                    rednumbers++;
                    break;
                }
            }
        }
        //蓝球号码是否命中
        bluenumbers=lucknumbers[6]==usernumbers[6]?1:0;
        System.out.println("中奖号码是：");
        printArray(lucknumbers);
        System.out.println("投注号码是：");
        printArray(usernumbers);
        System.out.println("你命中了几个红球:"+rednumbers);
        System.out.println("你是否命中蓝球:"+(bluenumbers==1?"是":"否"));
        //判断中奖情况
        if(bluenumbers==1&&rednumbers<3){
            System.out.println("恭喜你中了5元奖");
        } else if (bluenumbers==1&&rednumbers==3||bluenumbers==0&&rednumbers==4) {
            System.out.println("恭喜你中了10元奖");
        }else if (bluenumbers==1&&rednumbers==4||bluenumbers==0&&rednumbers==5) {
            System.out.println("恭喜你中了200元奖");
        } else if (bluenumbers==1&&rednumbers==5) {
            System.out.println("恭喜你中了3000元奖");
        }else if (bluenumbers==0&&rednumbers==6) {
            System.out.println("恭喜你中了500万元奖");}
        else if (bluenumbers==1&&rednumbers==6) {
            System.out.println("恭喜你中了1000万元奖");}
        else {
            System.out.println("感谢你为彩票作出的突出贡献");
        }
    }
    public static void printArray(int arr[]){
        System.out.print("{");
        for (int i = 0; i < arr.length ; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
    }
    public static int[] userinputnumbers(){
        //1.定义一个方法让用户存储7个号码
        int numbers[]=new int[7];
        //2.让用户录入6个红球号码
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < numbers.length-1 ; i++) {
            System.out.println("请你输入第"+(i+1)+"个红球号码");
            int data=sc.nextInt();
            //3.把当前录入的数据存入数组中去
            numbers[i]=data;
        }
        //录蓝球号码
        System.out.println("请你输入蓝球号码:");
        numbers[6]=sc.nextInt();
        return numbers;
    }
    public static int[] creatlucknumber(){
        //1.定义动态化数组，存储7个数字
        int numbers[]=new int[7];
        //2.遍历数组，为每个位置生成对应的号码(遍历前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;
                //3.必须判断随机号码之前是否出现过，直到不重复为止
                //定义一个标记位
                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;
                }
            }
        }
        //4.为第七个位置生成1-16的号码作为蓝球号码
        numbers[numbers.length-1]=r.nextInt(16)+1;
        return numbers;
    }
}