案例练习工程
本篇定位
本篇聚合 IDEA 工程 case-exercise-app 的全部源码练习（2025-12 学），按包分节全文收录——当年的学习注释（// 目标：… // 需求：…）原样保留，是最真实的练习轨迹。工程怎么建、模块/包/类怎么管理见 00-管理项目。
包含 9 个 .java 练习，目录结构：
case-exercise-app/src/
├── com/zwnsyw/Test1.java
├── com/zwnsyw/Test2.java
├── com/zwnsyw/Test3.java
├── com/zwnsyw/Test4.java
├── com/zwnsyw/Test5.java
├── com/zwnsyw/Test6.java
├── com/zwnsyw/Test7 2.java
├── com/zwnsyw/Test7.java
└── com/zwnsyw/Test8.java
练习案例
9 个综合练习（default 目录直挂 src/com/zwnsyw 下）。
Test1.java
package com.zwnsyw;
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;
}
}
Test2.java
package com.zwnsyw;
import java.util.Random;
public class Test2 {
public static void main(String[] args) {
// 目标：完成生成随机验证码。
System.out.println(createCode(8));
}
public static String createCode(int n){
// 1、定义一个for循环用于控制产生多少位随机字符
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;
}
}
Test3.java
package com.zwnsyw;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
// 目标：完成评委打分案例。
System.out.println("当前选手得分是：" + getAverageScore(6));
}
public static double getAverageScore(int number){
// 1、定义一个动态初始化的数组，负责后期存入评委的打分
int[] scores = new int[number]; // 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);
}
}
Test4.java
package com.zwnsyw;
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;
}
}
Test5.java
package com.zwnsyw;
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("]");
}
}
Test6.java
package com.zwnsyw;
public class Test6 {
}
Test7 2.java
package com.zwnsyw.demo;
public class Test7_2 {
public static void main(String[] args) {
// 目标：完成找素数2。
// 1、定义一个for循环，产生101-200之间的每个数据
int count = 0;
OUT: // 为外部循环指定标签
for (int i = 101; i <= 200; i++) {
// i = 101 102 103 ... 199 200
// 2、拦截判断该数是否是素数
for (int j = 2; j <= i / 2; j++) {
if(i % j == 0) {
// 这个数肯定不是素数，不能打印
continue OUT; // 结束外部循环的当次执行！
}
}
count++;
System.out.println(i);
}
System.out.println("个数是：" + count);
}
}
Test7.java
package com.zwnsyw;
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;
}
}
Test8.java
package com.zwnsyw;
import java.util.Random;
import java.util.Scanner;
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);
}
/** 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;
}
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("]");
}
/** 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;
}
/** 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("感谢您对福利事业做出的巨大贡献~~~");
}
}
}
💬 评论