Java奠基Java经典案例讲解
Posted 亦世凡华、
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java奠基Java经典案例讲解相关的知识，希望对你有一定的参考价值。
目录
卖飞机票
需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。按照如下规则计算机票价格：
旺季（5-10月）头等舱9折，经济舱8.5折；淡季（11月到来年4月）头等舱7折，经济舱6.5折。代码如下：
import java.util.Scanner;
public class Main
public static void main(String[] args)
// 键盘录入机票原价、月份、头等舱或经济舱
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票原价");
int ticket = sc.nextInt();
System.out.println("请输入月份");
int month = sc.nextInt();
System.out.println("请输入当前购买的舱位 0 头等舱 1 经济舱");
int seat = sc.nextInt();
// 判断月份是淡季还是旺季
if(month >= 5 && month <= 10) // 旺季
ticket = getTicket(seat, ticket, 0.9, 0.85);
else if((month >=1 && month <= 4) || (month >= 11 && month <= 12)) // 淡季
ticket = getTicket(seat, ticket, 0.7, 0.65);
else
System.out.println("键盘录入不合法！");
System.out.println(ticket);
// 定义判断乘坐的是经济舱还是头等舱
static int getTicket(int seat, int ticket, double x, double x1)
if (seat == 0)
ticket = (int) (ticket * x);
else if (seat == 1)
ticket = (int) (ticket * x1);
else
System.out.println("没有这个舱位！");
return ticket;
找质数
需求：判断101 ~ 200 之间有多少个素数，并输出所有素数。代码如下：
public class Main
public static void main(String[] args)
// 统计素数的数量
int count = 0;
for (int i = 101; i <= 200 ; i++)
// 假设当前i为素数
boolean flag = true;
for (int j = 2; j < i ; j++)
if(i % j ==0)
flag = false;
break;
if(flag)
System.out.println("当前的素数为："+i);
count++;
System.out.println("一共有素数"+count+"个");
开发验证码
需求：定义方法实现随机产生一个5位的验证码，验证码格式为：长度为5、前四位是大写字母或者小写字母、最后一位是数字。代码如下：
public class Main
public static void main(String[] args)
// 大小写字母都放在数组中
char[] chs = new char[52];
for (int i = 0; i < chs.length; i++)
// 使用 ASCII码表
if(i<=25)
chs[i] = (char) (97 + i); // 添加小写字母
else
chs[i] = (char) (65 + i - 26); // 添加大写字母
// 定义一个字符串类型用来记录最终结果
String result = "";
// 随机抽取四次字母
Random r = new Random();
for (int i = 0; i < 4; i++)
int randomIndex = r.nextInt(chs.length);// 利用随机索引获取对应元素
result = result + chs[randomIndex];
// 随机抽取一个数字 0 ~ 9
int number = r.nextInt(10);
result = result + number;
System.out.println("当前验证码为："+result);
数组元素的复制
需求：把一个数组中的元素复制到另一个新数组中去。代码如下：
public class Main
public static void main(String[] args)
// 定义一个旧数组用来存储数据
int[] arr = 1,2,3,4,5;
// 定义一个新数组，数组长度与旧数组长度一致
int[] newarr = new int[arr.length];
// 遍历旧数组，得到数组中的每一个元素依次放入到新数组当中
for (int i = 0; i < arr.length; i++)
newarr[i] = arr[i];
// 打印新数组中的元素
for (int i = 0; i < newarr.length; i++)
System.out.println(newarr[i]);
评委打分
需求：在唱歌比赛中，有6名评委给选手打分，分数范围是 [0 - 100]之间的整数。选手的最后得分为：去掉最高分、最低分的4个评委的平均分，请完成上述过程并计算选手的得分。代码如下：
public class Main
public static void main(String[] args)
// 定义一个数组，用来存储6名评委的打分（0 ~ 100）
int[] scoreArr = getScore();
for (int i = 1; i < scoreArr.length; i++)
System.out.println(scoreArr[i]);
// 求数组最大最小值
int max = getMax(scoreArr);
int min = getMin(scoreArr);
// 求数组元素6个元素的总和
int sum = getSum(scoreArr);
// 当前的评分
System.out.println("选手的最终评分为："+(sum - max - min)/(scoreArr.length - 2));
// 获取数组元素总和
public static int getSum(int[] scoreArr)
int sum = 0;
for (int i = 0; i < scoreArr.length; i++)
sum = sum + scoreArr[i];
return sum;
// 定义获取数组元素最大值的方法
public static int getMax(int[] scoreArr)
int max = scoreArr[0];
for (int i = 1; i < scoreArr.length; i++)
if(max>scoreArr[i])
max = scoreArr[i];
return max;
// 定义获取数组元素最小值的方法
public static int getMin(int[] scoreArr)
int min = scoreArr[0];
for (int i = 0; i < scoreArr.length; i++)
if(min<scoreArr[i])
min = scoreArr[i];
return min;
// 定义获取评委打分的方法
public static int[] getScore()
// 定义数组
int[] scores = new int[6];
// 使用键盘录入的方式，输入分数：0~100
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length;)
System.out.println("请输入评委的打分：");
int score = sc.nextInt();
if(score >=0 && score <= 100)
scores[i] = score;
i++;
else
System.out.println("成绩超出了范围，请继续录入！");
return scores;
数字加密
需求：某系统的数字密码（大于0），比如1983，采用加密方式进行传输。规则如下：先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数，比如1983加密之后变成8346。代码如下：
public class Main
public static void main(String[] args)
// 把整数里面的每一位放在数组当中
int[] arr = 1,9,8,3 ;
// 对数组上的每一位元素加5
for (int i = 0; i < arr.length; i++)
arr[i] = arr[i] + 5;
// 将数组的每一位元素进行10取余
for (int i = 0; i < arr.length; i++)
arr[i] = arr[i] % 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);
数字解密
需求：对上面的加密进行解密，比如加密的8346解密成1983，代码如下：
public class Main
public static void main(String[] args)
// 把整数里面的每一位放在数组当中
int[] arr = 8,3,4,6 ;
// 反转
for (int i = 0, j = arr.length-1; i < j; i++,j--)
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
// 由于加密是对10进行取余方式获取的，在解密的时候需要判断，0~4之间+10 4~9不变
for (int i = 0; i < arr.length; i++)
if(arr[i]>0 && arr[i]<=4)
arr[i] = arr[i] + 10;
// 数组每一位元素减5
for (int i = 0; i < arr.length; i++)
arr[i] = arr[i] - 5;
// 获取数组每一位元素拼接成最终结果
int number = 0;
for (int i = 0; i < arr.length; i++)
number = number * 10 + arr[i];
System.out.println(number);
抢红包
需求：一个大V直播抽奖，奖品是现金红包，分别有 2,588,888,1000,10000 五个奖金，请使用代码模拟抽奖，打印出每个奖项，奖项出现的顺序要随机且不能重复，代码如下：
public class Main
public static void main(String[] args)
// 定义一个奖池数组
int[] arr = 2,588,888,1000,10000 ;
// 定义新数组用于存储抽奖的结果
int[] newArr = new int[arr.length];
// 抽奖
Random r = new Random();
for (int i = 0; i < 5;)
// 获取随机索引
int randomIndex = r.nextInt(arr.length);
// 获取奖项
int prize = arr[randomIndex];
// 判断当前的奖项是否存在，如果存在则重新抽取，如果不存在，就表示是有效奖项
boolean flag = contains(newArr,prize);
if(!flag)
// 把当前抽取到的奖项添加到newArr当中
newArr[i] = prize;
// 添加完毕移动索引
i++;
// 遍历newArr
for (int i = 0; i < newArr.length; i++)
System.out.println(newArr[i]);
// 判断prize在数组中是否存在
public static boolean contains(int[] arr,int prize)
for (int i = 0; i < arr.length; i++)
if(arr[i] == prize)
return true;
return false;
模拟双色球
需求：投注号码由6个红色球号和1个蓝色球号组成。红色球号码从 1 ~ 33 中选择；蓝色球号码从 1 ~ 16 中选择。代码如下：
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class Main
public static void main(String[] args)
// 生成中将代码
int[] arr = createNumber();
System.out.println("当前中将代码为"+ Arrays.toString(arr) + "请仿照中将代码输入，才能中将(doge)");
// 用户输入的号码
int[] userInputArr = InputNum();
// 判断用户的中将情况
int redCount = 0;
int blueCount = 0;
// 判断红球
for (int i = 0; i < userInputArr.length - 1; i++)
int reqNumber= userInputArr[i];
for (int j = 0; j < arr.length -1; j++)
if(reqNumber == arr[j])
redCount++;
// 如果找到了，那么后面的数字就没有必要继续比较了，跳出内循环，继续判断下一个红球号码是否中将。
break;
// 判断蓝球
int blueNumber = userInputArr[userInputArr.length -1];
if(blueNumber == arr[arr.length -1])
blueCount++;
// 根据红球的个数以及蓝球的个数来判断中奖情况
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 ==2 && blueCount ==1) || (redCount ==1 && blueCount ==1) || (redCount ==0 && blueCount ==1))
System.out.println("恭喜你，中将5！");
else
System.out.println("谢谢参与，谢谢惠顾！");
public static int[] InputNum()
// 创建数组用于添加用户购买的彩票数量
int[] arr = new int[7];
// 利用键盘录入让用户进行输入
Scanner sc = new Scanner(System.in);
// 让用户输入红色球
for (int i = 0; i < 6;)
System.out.println("请输入第" + (i + 1) + "个红色号码");
int reqNumber = sc.nextInt();
// reqNumber 在 1~33 唯一不重复
if(reqNumber >= 1 && reqNumber <= 33)
boolean flag = contains(arr,reqNumber);
if(!flag)
// 不存在的，有效的可以存在数组当中
arr[i] = reqNumber;
i++;
else
// 存在
System.out.println("当前的红色号码球已经存在，请重新输入！");
else
System.out.println("当前的红色号码超出范围，请重新输入！");
// 让用户输入蓝色球
System.out.println("请输入蓝色球");
// 1~16
while (true)
int blueNumber = sc.nextInt();
if(blueNumber >=1 && blueNumber <=16)
arr[arr.length -1] = blueNumber;
break;
else
System.out.println("当前蓝球号码超出范围，请重新输入！");
return arr;
public static int[] createNumber()
// 创建数组用于添加中将号码，6个红球、1蓝球，数组长度为7
int[] arr = new int[7];
// 随机生成号码并添加到数组中
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++;
// 生成蓝球号码并添加到数组当中
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;
PS：赌博有风险，入行需谨慎！根据上面的赌球代码，我测试了好几次连5元都没中。希望大家玩乐适度为主，切莫上头！
二维数组
需求：某商城每个季度的营业额如下：单位（万元）
第一季度：22，66，44
第二季度：77，33，88
第三季度：25，45，65
第四季度：11，66，99
要求计算出每个季度的总营业额和全年的总营业额：代码如下：
public class Main
public static void main(String[] args)
// 创建二维数组并存储数据
int[][] yearArrArr =
22, 66, 44,
77, 33, 88,
25, 45, 65,
11, 66, 99
;
// 全年的营业额
int yearSum = 0;
// 遍历二维数组，得到每一个一维数组并求和
for (int i = 0; i < yearArrArr.length; i++)
int[] quarterArr = yearArrArr[i];
int sum = getSum(quarterArr);
System.out.println("第" + (i+1) + "个季度的总营业额为：" + sum);
yearSum = yearSum + sum;
System.out.println("全年的总营业额为："+yearSum);
// 定义一个方法，计算每一个季度的营业额
public static int getSum(int[] arr)
int sum = 0;
for (int i = 0; i < arr.length; i++)
sum = sum + arr[i];
return sum;
Java奠基方法的讲解与使用
目录
方法概述
方法是程序中最小的执行单元，在实际开发中会将重复的具有独立功能的代码抽取到方法中，这样可以提高代码的复用性和可维护性。
方法的定义与调用
在Java中定义方法的格式都是相同的，不过根据具体的需要可以抽离成以下三种形式方法，如下：
最简单的方法定义，格式如下：
public static void 方法名() 方法体(就是打包起来的代码) ;
public class Main
public static void main(String[] args)
// 调用say方法
say();
// 定义一个方法
public static void say()
System.out.println("你好，世界！"); // 你好，世界！
带参数的方法定义，格式如下：
public static void 方法名(参数1,参数2....) 方法体 ;
求和
public class Main
public static void main(String[] args)
// 调用getSum方法
getSum(10,20); // 实参，方法调用中的参数
// 定义一个方法
public static void getSum(int n,int m) // 形参，方法定义中的参数
int sum = n + m;
System.out.println(sum);
打印原数组
public class Main
public static void main(String[] args)
// 将数组进行打印在控制台
int[] arr = 12,14,15,16,17,18;
// 调用方法
printArr(arr); // [12,14,15,16,17,18]
// 定义一个方法
public static void printArr(int[] arr)
System.out.print("[");
for (int i = 0; i < arr.length; i++)
if(i==arr.length-1)
System.out.print(arr[i]);
else
System.out.print(arr[i]+",");
System.out.print("]");
带返回值的方法定义，格式如下：
public static 返回值类型 方法名 (参数) 方法体; return 返回值; ;
如果想在调用处要根据方法的结果，去编写另外一段代码的逻辑，为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法。方法的返回值其实就是方法运行的最终结果。
数组求和
public class Main
public static void main(String[] args)
// 直接调用，如果是带有返回值的方法，是没有任何结果的
getSum(10,20,30);
// 赋值调用
int result = getSum(10,20,30);
System.out.println(result); // 60
// 输出调用
System.out.println(getSum(10,20,30)); // 60
// 定义一个方法
public static int getSum(int n,int m,int x)
int sum = n + m + x;
return sum;
数组求最大值
public class Main
public static void main(String[] args)
// 将数组进行打印在控制台
int[] arr = 12,14,15,16,17,18;
// 调用方法
int result = getMax(arr);
// 打印
System.out.println(result); // 18
// 定义一个方法
public static int getMax(int[] arr)
int max = arr[0];
for (int i = 1; i < arr.length; i++)
if(max<arr[i])
max = arr[i];
return max;
判断数组是否存在元素
public class Main
public static void main(String[] args)
// 定义数组
int[] arr = 12,14,15,16,17,18;
// 判断一个数字是否在数组中存储
boolean result = decide(arr,10);
// 打印结果
System.out.println(result); // false
// 定义一个方法
public static boolean decide(int[] arr,int number)
for (int i = 0; i < arr.length; i++)
if(arr[i] == number)
return true;
// 当数组中的所有数据比较完毕之后，还是没有任何结果则执行以下语句。
return false;
拷贝数组
public class Main
public static void main(String[] args)
// 定义数组
int[] arr = 12,14,15,16,17,18;
// 调用方法拷贝数据
int[] copyArr = copyArr(arr,1,4);// 14 15 16
// 遍历copyArr
for (int i = 0; i < copyArr.length; i++)
System.out.print(copyArr[i]+" ");
// 定义一个方法
public static int[] copyArr(int[] arr,int from,int to)
// 定义数组
int[] newArr = new int[to - from];
// 伪造索引
int index = 0;
for (int i = from; i < to; i++)
newArr[index] = arr[i];
index++;
// 将新数组返回
return newArr;
注意：
方法不调用就不执行
方法与方法之间是平级关系，不能互相嵌套定义
方法的编写顺序和执行顺序无关
方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写。如果要编写return，后面不能跟具体的数据。return语句下面，不能编写代码，因为永远执行不到，属于无效代码。
方法的重载
在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系。
简单理解：同一个类中，方法名相同，参数不同的方法，与返回值无关。
参数不同：个数不同、类型不同、顺序不同。
public class Main
public static void main(String[] args)
// 调用方法
compare(1,2);
compare((byte)1,(byte)2);
compare((short)1,(short)2);
compare(1.1,2.2);
// 定义一个方法
public static void compare(byte b1,byte b2)
System.out.println("byte");
public static void compare(short s1,short s2)
System.out.println("short");
public static void compare(int i1,int i2)
System.out.println("int");
public static void compare(double d1,double d2)
System.out.println("double");
方法的值传递
传递基本数据类型时，传递的是真实的数据，形参的改变不影响实际参数的值：
public class Main
public static void main(String[] args)
int number = 100;
System.out.println("调用change方法前："+number);// 100
change(number);
System.out.println("调用change方法后："+number);// 100
// 定义一个方法
public static void change(int number)
number = 200;
如果想改变number的值，需要将方法中的number的值return出去来修改main方法的number内存值
传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值：
public class Main
public static void main(String[] args)
int[] arr = 10,130,12,14,144;
System.out.println("调用change方法前："+arr[1]);// 130
change(arr);
System.out.println("调用change方法后："+arr[1]);// 200
// 定义一个方法
public static void change(int[] arr)
arr[1] = 200;
以上是关于Java奠基Java经典案例讲解的主要内容，如果未能解决你的问题，请参考以下文章