day06-Java编程案例(专题)

day06——Java编程案例(专题)

    • 案例一:买飞机票
    • 案例二:开发验证码
    • 案例三:评委打分
    • 案例四:数字加密
    • 案例五:数组拷贝
    • 案例六:抢红包
    • 案例七:找素数
    • 案例八:模拟双色球[拓展案例]
      • 8.1 手动投注
      • 8.2 随机开奖号码
      • 8.3 判断是否中奖

案例一:买飞机票

day06-Java编程案例(专题)_第1张图片

我们来分析一下,这个需求该如何实现。将来我们去做一些需求,都是一个一个方法来实现的,所以在这里我们也采用方法来编写。

这个方法如何编写呢?采用下面的方式来思考

1.首先,考虑方法是否需要接收数据处理?
	阅读需求我们会发现,不同月份、不同原价、不同舱位类型优惠方案都不一样;
	所以,可以将原价、月份、舱位类型写成参数
	
2.接着,考虑方法是否有返回值?
	阅读需求我们发现,最终结果是求当前用户的优惠票价
	所以,可以将优惠票价作为方法的返回值。
	
3.最后,再考虑方法内部的业务逻辑
	先使用if判断月份是旺季还是淡季,然后使用switch分支判断是头等舱还是经济舱,计算		票价

代码如下
新建类:Test01

/*
    目标:完成买飞机票的案例
        需求:用户购买机票时,机票原价会按照淡季、旺季,头等舱还是经济舱的情况进行相应的优惠,优惠方案如下:
            5-10月为旺季,头等舱9折,经济舱8.5折; 11月到来年4月为淡季,头等舱7折,经济舱6.5折,
            请开发程序计算出用户当前机票的优惠价。
 */
public class Test01 {
    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;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
            }
        } else {
            // 淡季
            // 2.判断舱位
            switch (type) {
                case "头等舱":
                    price *= 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
            }
        }

        return price;
    }
}

案例二:开发验证码

我们学习第二个案例《开发验证码》,同样先阅读一下案例需求

day06-Java编程案例(专题)_第2张图片

分析一下,需求是要我们开发一个程序,生成指定位数的验证码。考虑到实际工作中生成验证码的功能很多地方都会用到,为了提高代码的复用性,我们还是把生成验证码的功能写成方法比较好。

那生成验证码的方法该怎么写呢?按照下面的三个步骤进行思考

1.首先,考虑方法是否需要接收数据处理?
	要求生成指定位数的验证码,到底多少位呢?让调用者传递即可
	所以,需要一个参数,用来表示验证码的位数

2.接着,考虑方法是否需要有返回值?
	该方法的结果,就是为了得到验证码
	所以,返回值就是验证码;

3.最后,再考虑方法内部的业务逻辑
	1)先按照方法接收的验证码位数n,循环n次
	2)每次循环,产生一个字符,可以是数字字符、或者大小写字母字符
	3)定义一个String类型的变量用于记住产生的每位随机字符

按照思路,编写代码如下

新建类:Test02

import java.util.Random;

/*
    目标:完成生成随机验证码
        开发一个程序,可以生成指定位数的验证码,每位可以是数字、大小写字母
 */
public class Test02 {
    public static void main(String[] args) {
        String code = createCode(4);
        System.out.println("生成验证码: " + code);
    }

    public static String createCode(int count) {
        char[] text = new char[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'a', 'b', 'c', 'd'};

        String code = "";
        Random r = new Random();
        for (int i = 0; i < count; i++) {
            // 为每个位置生成一个随机字符:可能是数字、大小写字母
            // 0表示数字,1表示大写字母,2表示小写字母
            int type = r.nextInt(3);
            switch (type) {
                case 0:
                    // 0表示数字
                    code += r.nextInt(10); // 0到9的数字
                    break;
                case 1:
                    // 1表示大写字母  A 65   Z 65+25    65 + (0 到 25)
                    char ch1 = (char) (65 + r.nextInt(26));
                    code += ch1;
                    break;
                case 2:
                    // 2表示小写字母  a 97   z 97+25    97 + (0 到 25)
                    char ch2 = (char) (97 + r.nextInt(26));
                    code += ch2;
                    break;
            }
        }

        return code;
    }
}

案例三:评委打分

day06-Java编程案例(专题)_第3张图片

1.首先,考虑方法是否需要接收数据来处理?
	需求中说,有多个评委的打分,但是到底多少个评委呢? 可以由调用者传递
	所以,我们可以把评委的个数写成参数;

2.接着,考虑方法是否需要有返回值?
	需求中,想要的最终结果是平均分
	所以,返回值就是平均分;

3.最后,再考虑方法内部的业务逻辑
	1)假设评委的个位为n个,那么就需要n个评委的分数,首先可以新建一个长度为n的数组,		用来存储每一个评委的分数
	
	2)循环n次,使用Scanner键盘录入n个1~100范围内的整数,并把整数存储到数组中
	
	3)求数组中元素的总和、最大值、最小值
	
	4)最后再计算平均值; 平均值 = (-最大值-最小值)/(数组.length-2);

代码如下

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);
    }
}

案例四:数字加密

day06-Java编程案例(专题)_第4张图片

仔细阅读需求后发现,简答来说该需求要做的事情,就是把一个4位数的整数,经过一系列的加密运算(至于怎么运算,待会再详细分析),得到一个新的整数。

我们还是把这个需求用方法来实现,按照下面的思维模式进行分析

1.首先,考虑方法是否需要接收数据处理?
	需要一个4位数,至于是哪一个数,让方法的调用者传递。
	所以,方法的参数,就是这个需要加密的四位数

2.接着,考虑方法是否需要有返回值?
	方法最终的结果是一个加密后的数据
	所以,返回值就表示为加密后的数据。

3.最后,再考虑方法内部的业务逻辑,这里的业务逻辑就是那一系列的加密运算
	1)先要把4位数整数拆分为,4个数字,用一个数组保存起来
	2)再将数组中的每一个元素加5,再对10取余
	3)最后将数组中的元素反转,
	

新建类:Test04

/*
    目标:完成数字加密程序的开发
 */
public class Test04 {
    public static void main(String[] args) {
        String encrypt = encrypt(1983);
        System.out.println("加密后: " + encrypt); // 8346
    }

    public static String encrypt(int number) {
        // 1983
        // 1.把这个密码拆分成一个一个的数字
        int[] numbers = new int[4];
        numbers[0] = number / 1000;
        numbers[1] = (number / 100) % 10;
        numbers[2] = (number / 10) % 10;
        numbers[3] = number % 10;
        // numbers = [1, 9, 8, 3];

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

        // 3.对数组反转,把对数组进行反转的操作交给一个独立的方法来完成
        reverse(numbers);

        // 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]
        for (int i = 0, j = numbers.length - 1; i < j; i++, j--) {
            int temp = numbers[j];
            numbers[j] = numbers[i];
            numbers[i] = temp;
        }
    }
}

案例五:数组拷贝

day06-Java编程案例(专题)_第5张图片

仔细阅读需求发现,想要实现的效果就是:给定一个数组,然后经过我们编写的程序,得到一个和原数组一模一样的数组。

我们也采用一个方法来编写,按照下面的思维模式来思考

1.首先,考虑方法是否需要接收数据处理?
	该方法的目的是拷贝数组,拷贝哪一个数组呢? 需要调用者传递
	所以,参数应该是一个数组

2.接着,考虑方法是否需要有返回值?
	该方法最终想要得到一个新数组
	所以,返回值是拷贝得到的新数组

3.最后,考虑方法内部的业务逻辑?
	1)创建一个新的数组,新数组的长度和元素数组一样
	2)遍历原数组,将原数组中的元素赋值给新数组
	3)最终将新数组返回
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("]");
    }
}

案例六:抢红包

day06-Java编程案例(专题)_第6张图片
day06-Java编程案例(专题)_第7张图片

我们还是把这个案例用一个方法来编写,同样按照下面的模式来分析

1.首先,考虑方法是否需要接收数据处理?
	需要接收5个红包,至于是哪5个红包,可以有调用者传递;把5个红包的数值,用数组来存	 储。
	所以,参数就是一个数组
	
2.接着,考虑方法是否需要有返回值?
	按照需求的效果,抢完红包就直接打印了,不需要返回值

3.最后,考虑方法内部的业务逻辑是怎么的?
	思考:红包实际上是数组中的元素,抢红包实际上随机获取数组中的元素;而且一个红包只能抢一次,怎么做呢?我们可以把数组中获取到元素的位置,置为0,下次再或者这个位置的元素一判断为0,再重新获取新的元素,依次内推,直到把数组中所有的元素都获取完。
	
	我们我们把抽红包的思路再整理一下:
		1)先把数组里面的5个金额打乱顺序
		2)按顺序取出来

新建类:Test06

import java.util.Random;

/*
    目标:抢红包
        一个大V直播时发起了抢红包活动,分别有:9、666、188、520、99999五个红包。
        请模拟粉丝来抽奖,按照先来先得,随机抽取,抽完即止,注意:一个红包只能被抽一次,先抽或后抽哪一个红包是随机的
 */
public class Test06 {
    public static void main(String[] args) {
        int[] money = {9, 666, 188, 520, 99999};
        sendRedPacket(money);
    }

    public static void sendRedPacket(int[] money) {
        // 先把数组里面的5个金额打乱顺序
        Random r = new Random();
        for (int i = 0; i < money.length; i++) {
            int index = r.nextInt(money.length);
            int tmp = money[i];
            money[i] = money[index];
            money[index] = tmp;
        }

        // 按顺序取出来
        for (int i = 0; i < money.length; i++) {
            System.out.println("第" + (i + 1) + "个红包: " + money[i]);
        }
    }
}

案例七:找素数

day06-Java编程案例(专题)_第8张图片

首先我们得统一认识一下什么是素数:只能被1和本身整除的数是素数,比如:3、7是素数,9,21不是素数(因为9可以被3整除,21可以被3和7整除)

再思考题目需求该怎么做?打印输出101~200之间的素数,并求有多少个?,我们也是把这个需求写成一个方法,还是按照三个步骤分析方法如何编写。

1.首先,考虑方法是否需要接收数据处理?
	该方法是求一个范围内的素数,一个范围需要两个数据来确定,比如:101~200
	所以,方法需要两个参数来接收范围的开始值start,和范围的结束值end
	
2.接着,考虑方法是否需要返回值?
	该方法需要求一个范围内的素数的个数
	所以,返回值就是素数的个数

3.最后,考虑方法内部的业务逻辑
	思考:怎么判断一个数是素数呢?要仅仅抓住,素数的要求:“只能被1和本身整除的数是素数”。我们可以从反向思考,如果这个数只要能被除了1和本身以外的数整除,那么这个数就不是素数。
	//比如1:判断9是否为素数
	int num = 9;
	boolean flag = true; //规定flag等于true表示num是素数;否则表示num不是素数
	//如果这个数num只要能被除了1和本身以外的数整除,那么这个数就不是素数。
	for(int j=2; j<9-1; j++){
        //当j=3时,num%j == 9%3 == 0; 
		if(num%j==0){
            //说明num=9; 表示一个素数。把flag改为false; 
            flag = false;
		}
	}

	把上面的代码循环执行,每次循环然后把num换成start~end之间的整数即可。

编写代码如下

新建类:Test06

/*
    目标:找素数
        找出101到200之间的有多少个素数,并输出所有素数
            什么是素数:除了1和它本身以外,不能被其他正整数整除
            比如:3、7就是素数,而9、21等等不是素数。
 */
public class Test07 {
    public static void main(String[] args) {
        int count = primeNumber(101, 200);
        System.out.println("当前素数的个数是: " + count);
    }

    private static int primeNumber(int start, int end) {
        // 记录数量
        int count = 0;
        for (int i = start; i <= end; i++) {
            // i = 101, 102, 103, ... 200
            // 标记思想, 假设是一个素数
            boolean flag = true;

            // 判断当前数字i是否是素数
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    // 102 / 2 = 51 能被除尽,说明不是素数
                    flag = false;
                    break;
                }
            }

            // 判断这个数字是否是素数
            if (flag) {
                System.out.println(i);
                count++;
            }
        }

        return count;
    }
}

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

day06-Java编程案例(专题)_第9张图片

这个案例我们可以采用方法方法来完成

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

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

8.1 手动投注

编写一个方法,让用户手动投注,产生一注双色球彩票,思路分析

1.首先,考虑方法是否需要接收数据处理?
	双色球彩票的规则非常明确,没有什么数据需要传递给方法。
	所以,不需要参数

2.接着,考虑方法是否需要返回值?
	方法最终的结果是需要一注双色球彩票的号码,一注彩票有7个号码,可以用一个数组来存
	所以,返回值是一个数组

3.最后,考虑方法内部的业务逻辑怎么编写?
	1)首先需要准备一个int类型数组,长度为7; 用于存储产生的投注号码
	2)循环遍历数组的前6个元素,采用键盘录入的方式,给前区6个红球赋值
		要求录入的整数在1~33范围内,同时录入的整数在数组中不能已存在,否则重新录入
	3)最后再录入一个整数,给后区一个蓝球赋值
		要求整数必须在1~16范围内
  • 手动投注代码如下
// 1.模拟用户选择一注双色球
public static int[] userNumbers() {
    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);
    // 生成6个红球
    for (int i = 0; i < 6; i++) {
        // i = 0, 1, 2, 3, 4, 5

        while (true) {
            System.out.println("请您输入第" + (i + 1) + "个红球号码(1-33之间,不能重复):");
            int redNumber = sc.nextInt();

            // 5.判断输入的红球号码是不是在1到33之间
            if (redNumber < 1 || redNumber > 33) {
                System.out.println("对不起,您输入的号码不在1到33之间");
            } else {
                if (exist(numbers, redNumber)) {
                    System.out.println("对不起,您当前输入的红球号码重复了,请确认!" + redNumber);
                } else {
                    numbers[i] = redNumber;
                    break;
                }
            }
        }
    }

    // 生成1个蓝球
    System.out.println("请您输入最后1个蓝球号码(1-16): ");
    int blueNumber = sc.nextInt();
    if (blueNumber < 1 || blueNumber > 16) {
        System.out.println("对不起,您输入的蓝球号码范围不对!");
    } else {
        numbers[6] = blueNumber;
    }

    return numbers;
}

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

// 判断number这个数字是否在numbers数组中存在
public static boolean exist(int[] numbers, int number) {
    for (int i = 0; i < numbers.length; i++) {
        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 static void main(String[] args) {
    int[] userNumbers = userNumbers();
    printArray(userNumbers);
}

8.2 随机开奖号码

编写一个方法,让用户自动机选投注,产生一注双色球彩票,思路分析

1.首先,考虑方法是否需要接收数据处理?
	双色球彩票的规则非常明确,没有什么数据需要传递给方法。
	所以,不需要参数

2.接着,考虑方法是否需要返回值?
	方法最终的结果是需要一注双色球彩票的号码,一注彩票有7个号码,可以用一个数组来存
	所以,返回值是一个数组

3.最后,考虑方法内部的业务逻辑怎么编写?
	1)首先需要准备一个int类型数组,长度为7; 用于存储产生的投注号码
	2)循环遍历数组的前6个元素,采用生成随机数的的方式,给前区6个红球赋值
		要求生成的随机数在1~33范围内,同时随机的整数数组中不能已存在,否则重新生产
	3)最后再随机一个整数,给后区一个蓝球赋值
		要求随机整数必须在1~16范围内

机选号码,代码如下

// 2.模拟双色球开奖号码
public static int[] luckNumbers() {
    int[] numbers = new int[7];
    // numbers = [0, 0, 0, 0, 0, 0, 0]
    //       索引 0  1  2  3  4  5  6

    Random r  = new Random();
    // 生成6个红球
    for (int i = 0; i < 6; i++) {
        // i = 0, 1, 2, 3, 4, 5

        while (true) {
            int redNumber = 1 + r.nextInt(33);

            if (!exist(numbers, redNumber)) {
                numbers[i] = redNumber;
                break;
            }
        }
    }

    // 生成1个蓝球
    int blueNumber = 1 + r.nextInt(16);
    numbers[6] = blueNumber;

    return numbers;
}

在main方法中测试,看是否能够产生一注彩票

public static void main(String[] args) {
    int[] userNumbers = userNumbers();
    printArray(userNumbers);

    int[] luckNumbers = luckNumbers();
    printArray(luckNumbers);
}

8.3 判断是否中奖

编写一个方法,判断用户的彩票号码是否中奖,具体中奖规则如下

  • 6个红球+1个蓝球 ,奖金1000万

  • 6个红球+0个蓝球,奖金500万

  • 5个红球+1个蓝球,奖金3000块

  • 5个红球+0个蓝球,或者4个红球+1个蓝球,奖金200块

  • 4个红球+0个蓝球,或者3个红球+1个蓝球,奖金10块

  • 小于3个红球+1个蓝球,奖金5块

  • 如果前面的都不成立,就中奖,算你为福利事业做贡献了。

编写方法的思路如下

1.首先,考虑方法是否需要接收数据处理?
	判断彩票是否中奖,需要有两组号码;一组号码是彩票号码,一组号码是开奖号码
	所以,参数需要有两个数组

2.接着,考虑方法是否需要返回值?
	方法不需要返回结果,中了奖,直接将奖项打印输出就行了。
	【注意:这只是提供一种代码的编写方案,你将中奖的金额返回也行】

3.最后,考虑方法内部的业务逻辑怎么编写?
	1)定义两个变量redCount和blueCount用来记录,红球的个数和蓝球的个数
	2)遍历两个数组中前6个元素(红球),判断两个数组中有没有相同元素
		如果找到一个相同元素,则redCount++
    3)比较两个数组中最后一个元素(蓝球)是否相同
    	如果相同,则blueCount++
	4)根据红球和蓝球的命中个数,打印输出对应的奖项

代码如下

// 3.对比中奖情况
public static void compareNumber(int[] userNumbers, int[] luckNumbers) {
    // userNumbers = [12, 14, 16, 18, 23, 26, 8]
    // luckNumbers = [16, 17, 18, 19, 26, 32, 8]
    // 分别定义2个变量用于记住红球命中了几个以及蓝球命中了几个
    int redCount = 0;
    int blueCount = 0;

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

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

    System.out.println("您命中的红球数量是: " + redCount);
    System.out.println("您命中的蓝球数量是: " + 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 < 3 && blueCount == 1) {
        System.out.println("恭喜您,中奖5元,可以再买两注搏一下!");
    } else {
        System.out.println("感谢您对福利事业做出的巨大贡献!");
    }
}

在main方法中测试,检测是否中奖的方法是否正确

public static void main(String[] args) {
    int[] userNumbers = userNumbers();
    printArray(userNumbers);

    int[] luckNumbers = luckNumbers();
    printArray(luckNumbers);

    compareNumber(userNumbers, luckNumbers);
}

你可能感兴趣的:(JAVASE每日学习,java,开发语言,idea)