devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

(day9) 自学Java——常用API_java中jdk apl如何练习

作者：知新_RL | 2024-03-28 20:27:34

赞

踩

java中jdk apl如何练习

AIP就是Java已经写好的各种功能的java类

目录

1.Math

2.System

3.Runtime

4.Object

5.对象工具类Objects

6.BIgInteger

7.BigDecima

8.正则表达式

(1)爬虫

(2)带条件爬取，贪婪爬取和识别正则的两个方法

(3)捕获分组和非捕获分组

9.JDK7以前时间相关类

10.JDK8新增时间相关类

11.包装类

12.综合练习

1.Math

工具类：类名知其意，私有化构造方法，方法定义为静态。

Math是进行数学计算的工具类

Math的sqrt，开平方

Math的cbrt，开立方

Math的ceil(英语：天花板)，是向上取整

Math的floor(英语：地板)，是向下取整

Math的random的取值范围，0.0是闭区间(包括0.0)，1.0是开区间(不包括1.0)

Math的abs有个bug，比如，int类型的取值范围是 -2147483648~2147483647，如果Math.abs(-2147483648)的结果还是 -2147483648，因为int的范围不包括正数2147483648。

如果用Math.absExact(-2147483648)，超出范围会报错

 练习：判断一个数是否为质数

左边的因子小于等于平方根，右边的因子大于等于平方根。所以只用遍历平方根左边的因子即可

  1. public class MathDemo {
  2.     public static void main(String[] args) {
  3.         System.out.println(getPrime(7));
  4.     }
  5.  
  6.     public static boolean getPrime(int number) {
  7.         for (int i = 2; i <=Math.sqrt(number); i++) {
  8.             if (number%i==0){
  9.                 return false;
  10.             }
  11.         }
  12.         return true;
  13.     }
  14. }

练习：自幂数，一个n位自然数等于自身各个数位上数字的n次幂之和

要求1：统计一共有多少个水仙花数。

要求2：证明没有两位的自幂数。

要求3：分别统计有多少个四叶玫瑰数和五角星数（答案都为3）

  1. //要求1：统计一共有多少个水仙花数。
  2. public class MathDemo {
  3.     public static void main(String[] args) {
  4.         int count=0;
  5.         for (int i = 100; i <=999; i++) {
  6.             int ge=i%10;
  7.             int shi=i/10%10;
  8.             int bai=i/100%10;
  9.             double result=Math.pow(ge,3)+Math.pow(shi,3)+Math.pow(bai,3);
  10.             if (i==result){
  11.                 count++;
  12.                 System.out.println(i);
  13.             }
  14.         }
  15.         System.out.println(count+"个");
  16.     }
  17. }
  1. //要求2：证明没有两位的自幂数。
  2. public class MathDemo {
  3.     public static void main(String[] args) {
  4.         int count=0;
  5.         for (int i = 10; i <=99; i++) {
  6.             int ge=i%10;
  7.             int shi=i/10%10;
  8.             double result=Math.pow(ge,2)+Math.pow(shi,2);
  9.             if (i==result){
  10.                 count++;
  11.                 System.out.println(i);
  12.             }
  13.         }
  14.         System.out.println(count+"个");
  15.     }
  16. }
  1. //要求3：分别统计有多少个四叶玫瑰数和五角星数（答案都为3）
  2. public class MathDemo {
  3.     public static void main(String[] args) {
  4.         int count=0;
  5.         for (int i = 1000; i <=9999; i++) {
  6.             int ge=i%10;
  7.             int shi=i/10%10;
  8.             int bai=i/100%10;
  9.             int qian=i/1000%10;
  10.             double result=Math.pow(ge,4)+Math.pow(shi,4)+Math.pow(bai,4)+Math.pow(qian,4);
  11.             if (i==result){
  12.                 count++;
  13.                 System.out.println(i);
  14.             }
  15.         }
  16.         System.out.println(count+"个");
  17.     }
  18. }
  19. //----------------------------------------------------------------
  20. public class MathDemo {
  21.     public static void main(String[] args) {
  22.         int count=0;
  23.         for (int i = 10000; i <=99999; i++) {
  24.             int ge=i%10;
  25.             int shi=i/10%10;
  26.             int bai=i/100%10;
  27.             int qian=i/1000%10;
  28.             int wan=i/10000%10;
  29.             double result=Math.pow(ge,5)+Math.pow(shi,5)+Math.pow(bai,5)+Math.pow(qian,5)+Math.pow(wan,5);
  30.             if (i==result){
  31.                 count++;
  32.                 System.out.println(i);
  33.             }
  34.         }
  35.         System.out.println(count+"个");
  36.     }
  37. }

2.System

System也是一个工具类，提供了一些与系统相关的方法

 

1.如果数据源数组和目的地数组都是基本数据类型，两者类型必须保持一致，否则会报错

2.拷贝的时候需要考虑数组长度，超出范围，也会报错

3.如果数据源数组和目的地数组都是引用数据类型，子类类型可以赋值给父类

3.Runtime

1.Runtime表示当前虚拟机的运行环境

2.这个类里的方法不是静态的，想要调用方法，就要获取Runtime的对象。

3.Runtime的对象不能直接new，要用getRuntime()

4.Object

在顶级父类中只有无参的构造方法，因为不可能有所有事物的共性，也就没有参数

 

1.如果打印一个对象，想要看到属性值，那就要重写toString方法。

2.在重写方法中，把对象的属性值进行拼接。

1.如果没有重写equals方法，那么默认使用Object中的方法进行比较，比较地址值是否相等。

2.一般地址值对于我们意义不大，所以会重写，重写之后比较的是对象内部的属性值。

 

 对象克隆，把A对象的属性值完全拷贝给B，也叫对象拷贝，对象复制

 字符串在串池中，复用。

5.对象工具类Objects

Objects是一个对象工具类，提供了一些操作对象的方法。

6.BIgInteger

 BIgInteger是个对象，不能直接加减乘除等计算，都要用方法来完成。

 

  将二进制数按规则（32位为一组）分割，然后存到数组中，数组中第二个是补码

7.BigDecima

 BigDecima作用：1.用于小数的精确运算。

                                 2.用来表示很大的小数

1.如果表示的数字不大，没有超出double的取值范围，建议使用静态方法。

2.如果表示的数字比较大，超出了double的取值范围，建议使用构造方法。

3.如果传递的是0~10的之间整数，包括0和10，那么方法会返回已经创建好的对象，不会重

   新new，（10.0就会使用new，因为10.0不是int类型）。

 存储方式：遍历每个字符，然后转换为ascii码，放到数组中存储。

8.正则表达式

作用：1.校验字符串是否满足规则

            2.在一段文本中查找满足要求的内容

类：pattern（在api文档查看）

1.正则表达式中，从左到右，一个一个匹配。

2.[ ] 方括号表示一个范围 ，在这个范围里只能匹配一个字符。

3.{ }大括号表示匹配字符个数。例：{6，}至少匹配6个字符，{4}只匹配4个字符。

4.如果要求两个范围的交集，要用&&，不能只写一个，一个&只是一个简单的符号。

5.” \d “等使用时，需要加个” \ “（转义）

6.( )小括号表示分组。

7.  (?i)问号和字符i组合，可以忽略它后面字符的大小写。a(?i)bc，这个就会忽略bc的大小  

    写，所以 aBC是true。

编写写正则表达式： 1.按照正确数据进行拆分

                                     2.找出每部分规律，并编写正则表达式，每部拼接起来就是完整表达式

                                     3.从左到右书写

练习：

用正则表达式验证用户输入的手机号码是否满足要求，13276898988，13245647587

用正则表达式验证用户输入的邮箱是否满足要求，2909378766@qq.com，zhangsan@itcast.cnn

用正则表达式验证用户输入的座机电话号码是否满足要求，020-2323343，0712-2425687

  1. public class RegexDemo {
  2.     public static void main(String[] args) {
  3.         //匹配电话号码13276898988，15245647587
  4.         //第一位一定是1，第二位在3~9之间，后面的数字随机
  5.         String regex1="1[3-9]\\d{9}";
  6.         System.out.println("13276898988".matches(regex1)); //true
  7.         System.out.println("15245647587".matches(regex1)); //true
  8.         System.out.println("-------------------------");
  9.  
  10.         //匹配邮箱是否满足要求，2909378766@qq.com，zhangsan@itcast.cnn，dlei0009@pci.com.cn
  11.         //@前面部分：\w+
  12.         String regex2="\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
  13.         System.out.println("2909378766@qq.com".matches(regex2));
  14.         System.out.println("zhangsan@itcast.cnn".matches(regex2));
  15.         System.out.println("dlei0009@pci.com.cn".matches(regex2));
  16.         System.out.println("-------------------------");
  17.  
  18.         //匹配座机电话号码是否满足要求，020-2323343，0712-2425687，0212453424
  19.         //?表示匹配-，0次或1次
  20.         //-后面数字的第一位不能为0
  21.         String regex3="0\\d{2,3}-?[1-9]\\d{4,9}";
  22.         System.out.println("020-2323343".matches(regex3)); //true
  23.         System.out.println("0712-2425687".matches(regex3)); //true
  24.         System.out.println("0212453424".matches(regex3)); //true
  25.         System.out.println("-------------------------");
  26.     }
  27. }

练习：用正则完成以下需求

验证用户名是否满足要求：

        大小写字母，数字，下划线一共4-16位。

验证身份证号码是否满足要求：

        简单要求：18位，前17位任意数字，最后一位可以是数字，可以是大写或小写的x。

        复杂要求：按照身份证号码的格式严格要求。

  1. public class RegexDemo {
  2.     public static void main(String[] args) {
  3.         //用户名校验
  4.         //大小写字母，数字，下划线一共4-16位。
  5.         String regex1="\\w{4,16}";
  6.         System.out.println("zhangannn".matches(regex1)); //true
  7.         System.out.println("xxxx_ssss".matches(regex1)); //true
  8.         System.out.println("-----------------");
  9.         //乱写的511364874323458473，51156497432345847x，51136987432645847X
  10.         //18位，前17位任意数字，最后一位可以是数字，可以是大写或小写的x。
  11.         String regex2="[1-9]{17}[\\dxX]";  //或者[1-9]{17}(\\d|x|X)或者[1-9]{17}(\\d|(?i)x)
  12.         System.out.println("511364874323458473".matches(regex2));
  13.         System.out.println("51156497432345847x".matches(regex2));
  14.         System.out.println("51136987432645847X".matches(regex2));
  15.         System.out.println("-----------------");
  16.         //身份证号码严格校验
  17.         //前面6位：省份，市区，派出所等信息，第一位不能为0，后面5位是任意数字   [1-9]\\d{5}
  18.         //年份前半段：18，19，20     年份后半段：任意数字出现两次   (18|19|20)\\d{2}
  19.         //月份：01~09 10 11 12   (0[1-9]|1[0-2])
  20.         //日期：01~31   (0[1-9]|[12]\\d|3[01])
  21.         //最后四位：任意数字出现3次，最后一位可以是数字也可以是大写或小写的x  \\d{3}(\\d|(?i)x)
  22.         String regex3="[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}(\\d|(?i)x)";
  23.         System.out.println("51156187405291747x".matches(regex3));//错误的身份证false
  24.         System.out.println("51136197404202047X".matches(regex3));//错误的身份证false
  25.         System.out.println("513723180111050521".matches(regex3));//正确的身份证true
  26.     }
  27. }

(1)爬虫

Pattern：表示正则表达式

Matcher：文本匹配器，作用是按照正则表达式的规则去读取字符串，从头开始读取

（在大串中去找符合匹配规则的子串）

1.获取正则表达式的对象

Pattern p=Pattern.compile("Java\\d{0,2}");

2.获取文本匹配器的对象

Matcher m=p.matcher(str);

3.查找匹配内容是否存在

m.find();

4.获取查找到的能匹配的内容

m.group();

练习
本地爬虫和网络爬虫
有如下文本，请按照要求爬取数据。
Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和ava11，因为这
两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台。
要求：找出里面所有的JavaXX

  1. import java.util.regex.Matcher;
  2. import java.util.regex.Pattern;
  3.  
  4. public class RegexDemo {
  5.     public static void main(String[] args) {
  6.        String str="Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这\n" +
  7.                "两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
  8.        Pattern p=Pattern.compile("Java\\d{0,2}");
  9.        Matcher m=p.matcher(str);
  10.        while (m.find()){
  11.            System.out.println(m.group());
  12.        }
  13.     }
  14. }

练习
需求：把下面文本中的电话，邮箱，手机号，热线都爬取出来。
来黑马程序员学习Java，
电话：18512516758，18512508907
或者联系邮箱：boniu@itcast.cn，
座机电话：01036517895，010-98951256
邮箱：bozai@itcast.cn,
热线电话：400-618-9090，400-618-4000，4006184000，4006189090

  1. import java.util.regex.Matcher;
  2. import java.util.regex.Pattern;
  3.  
  4. public class RegexDemo {
  5.     public static void main(String[] args) {
  6.        String str="练习\n" +
  7.                "需求：把下面文本中的电话，邮箱，手机号，热线都爬取出来。\n" +
  8.                "来黑马程序员学习Java，\n" +
  9.                "手机号：18512516758，18512508907\n" +
  10.                "或者联系邮箱：boniu@itcast.cn，\n" +
  11.                "座机电话：01036517895，010-98951256\n" +
  12.                "邮箱：bozai@itcast.cn,\n" +
  13.                "热线电话：400-618-9090，400-618-4000，4006184000，4006189090";
  14.        //邮箱：\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}
  15.         //座机：010-?\\d{8}
  16.         //手机：1[3-9]\d{9}
  17.         //热线：400-?618-?[49]0[09]0
  18.         String regex="\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}|010-?\\d{8}|1[3-9]\\d{9}|400-?618-?[49]0[09]0";
  19.        Pattern p=Pattern.compile(regex);
  20.        Matcher m=p.matcher(str);
  21.         while (m.find()){
  22.             System.out.println(m.group());
  23.         }
  24.     }
  25. }

(2)带条件爬取，贪婪爬取和识别正则的两个方法

贪婪爬取：尽可能多的爬取数据。

非贪婪爬取：尽可能少的爬取数据。

（Java中默认贪婪爬取）

(3)捕获分组和非捕获分组

分组就是一个（）小括号

练习： 捕获分组就是把这一组的数据捕获出来，再用一次。
需求1：判断一个字符串的开始字符和结束字符是否一致？只考虑一个字符
举例： a123a    b456b    17891      &abc&
需求2：判断一个字符串的开始部分和结束部分是否一致？可以有多个字符
举例： abc123abc         b456b        123789123        &!@abc&!@
需求3：判断一个字符串的开始部分和结束部分是否一致？开始部分内部每个字符也需要一致
举例： aaa123aaa         bbb456bbb     111789111         &&abc&&

  1. public class RegexDemo {
  2.     public static void main(String[] args) {
  3. //        需求1：判断一个字符串的开始字符和结束字符是否一致？只考虑一个字符
  4. //        举例： a123a    b456b    17891      &abc&
  5. //                需求2：判断一个字符串的开始部分和结束部分是否一致？可以有多个字符
  6. //        举例： abc123abc         b456b        123789123        &!@abc&!@
  7. //                需求3：判断一个字符串的开始部分和结束部分是否一致？开始部分内部每个字符也需要一致
  8. //        举例： aaa123aaa         bbb456bbb     111789111         &&abc&&
  9.  
  10.         //需求1
  11.         String regex="(.).+\\1";
  12.         System.out.println("a123a".matches(regex));//true
  13.         System.out.println("b456b".matches(regex));//true
  14.         System.out.println("17891".matches(regex));//true
  15.         System.out.println("&abc&".matches(regex));//true
  16.         System.out.println("-------------------");
  17.         //需求2
  18.         String regex1="(.+).+\\1";
  19.         System.out.println("abc123abc".matches(regex1));//true
  20.         System.out.println("b456b".matches(regex1));//true
  21.         System.out.println("123789123".matches(regex1));//true
  22.         System.out.println("&!@abc&!@".matches(regex1));//true
  23.         System.out.println("-------------------");
  24.         //需求3
  25.         //(.)表示一个任意字符，把它看成一组
  26.         String regex2="((.)\\2*).+\\1";
  27.         System.out.println("aaa123aaa".matches(regex2));//true
  28.         System.out.println("bbb456bbb".matches(regex2));//true
  29.         System.out.println("111789111".matches(regex2));//true
  30.         System.out.println("&&abc&&".matches(regex2));//true
  31.     }
  32. }

练习：口吃替换

需求：将字符串：我要学学编编编编程程程程程

替换为：我要学编程

  1. public class RegexDemo {
  2.     public static void main(String[] args) {
  3.         String str="我要学学编编编编程程程程程";
  4.         String regex="(.)\\1+";
  5.         String result=str.replaceAll(regex,"$1");
  6.         System.out.println(result);
  7.     }
  8. }

9.JDK7以前时间相关类

 练习：将2000-11-11转换成2000年11月11日

  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4.  
  5. public class RegexDemo {
  6.     public static void main(String[] args) throws ParseException {
  7.         String str="2000-11-11";
  8.         //解析
  9.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  10.         Date d=sdf.parse(str);
  11.         //格式化
  12.         SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日");
  13.         String result=sdf1.format(d);
  14.         System.out.println(result);
  15.     }
  16. }

  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4.  
  5. public class RegexDemo {
  6.     public static void main(String[] args) throws ParseException {
  7.         String startTime="2023年11月11日 0:00:00";
  8.         String endTime="2023年11月11日 0:10:00";
  9.         String clickTimeJ="2023年11月11日 0:01:00";
  10.         String clickTimeP="2023年11月11日 0:11:00";
  11.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 H:mm:ss");
  12.         Date start = sdf.parse(startTime);
  13.         Date end = sdf.parse(endTime);
  14.         Date xiaoJ = sdf.parse(clickTimeJ);
  15.         Date xiaoP = sdf.parse(clickTimeP);
  16.         method(start, end, xiaoJ);  //参加上了
  17.         method(start, end, xiaoP);  //没参加上
  18.     }
  19.  
  20.     public static void method(Date start, Date end, Date xiao) {
  21.         if (start.getTime()<=xiao.getTime()&&end.getTime()>=xiao.getTime()){
  22.             System.out.println("参加上了");
  23.         }
  24.         else{
  25.             System.out.println("没参加上");
  26.         }
  27.     }
  28. }

1.Calendar是一个抽象类，不能直接new，而是通过一个静态方法获取到子类对象。

2.底层原理：会根据系统的不同时区来获取不同的日历对象，默认表示当前时间。

                    会把时间中的纪元，年，月，日，时，分，秒，星期，等等放到一个数组中。   

10.JDK8新增时间相关类

 

Instant.now()获取对象

上面两个是静态的，要用类名来调用；下面的要用对象来调用。

11.包装类

包装类：基本数据类型对应的引用类型

（简言说，就是将基本数据类型变成一个对象）

 

 

 

 

 键盘输入用nextLine()，然后进行类型转换。

12.综合练习

练习1：键盘录入一些1~100的整数，并添加到集合中，直到集合内数据和超过200为止。

  1. import java.util.ArrayList;
  2. import java.util.Scanner;
  3.  
  4. public class Test {
  5.     public static void main(String[] args){
  6.         //创建集合
  7.         ArrayList<Integer> al=new ArrayList<>();
  8.         Scanner sc = new Scanner(System.in);
  9.         while (true) {
  10.             System.out.print("请输入1~100的数字:");
  11.             String line = sc.nextLine();
  12.             Integer num = Integer.parseInt(line);
  13.             if (num<1||num>100){
  14.                 System.out.println("不符合要求");
  15.                 continue;
  16.             }
  17.             al.add(num);
  18.             int sum=0;
  19.             for (int i = 0; i < al.size(); i++) {
  20.                 sum=sum+al.get(i);
  21.             }
  22.             if (sum>=200){
  23.                 System.out.println(sum);
  24.                 return;
  25.             }
  26.         }
  27.     }
  28. }

练习2：自己实现parseInt方法的效果，将字符串形式的数据转成整数。

要求：字符串里只能是数字，不能有其他字符

            最少一位，最多十位

           0不能开头

  1. public class Test {
  2.     public static void main(String[] args){
  3.         String str="12345";
  4.         String regex="[1-9]\\d{0,9}";
  5.         if(!str.matches(regex)){
  6.             System.out.println("数据错误");
  7.         }else{
  8.             int result=0;
  9.             for (int i = 0; i < str.length(); i++) {
  10.                 int num=str.charAt(i)-'0';
  11.                 result=result*10+num;
  12.             }
  13.             System.out.println(result+1);//可以进行运算，所以已经转换成int类型了
  14.         }
  15.     }
  16. }

练习3：

定义一个方法自己实现toBinaryString方法的效果，将一个十进制整数转成字符串表示的二进制。

  1. public class Test {
  2.     public static void main(String[] args){
  3.         int num=8;
  4.         String str=toBinaryString(num);
  5.         System.out.println(str);
  6.     }
  7.  
  8.     private static String toBinaryString(int num) {
  9.         StringBuilder sb=new StringBuilder();
  10.         while (num!=0){
  11.             int remiandar=num%2;
  12.             //倒着拼接数据
  13.             sb.insert(0,remiandar);
  14.             num=num/2;
  15.         }
  16.         String result=sb.toString();
  17.         return result;
  18.     }
  19. }

练习4：使用代码实现计算你活了多少天，用JDK7和JDK8的两种方式完成

  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4.  
  5. public class Test {
  6.     public static void main(String[] args) throws ParseException {
  7.         //JDK7计算要用毫秒值
  8.         //出生日期的毫秒值
  9.         String birthday="2001-12-05";
  10.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  11.         Date birthTime = sdf.parse(birthday);
  12.         long time=birthTime.getTime();
  13.         //当前日期的毫秒值
  14.         long time2=System.currentTimeMillis();
  15.         //当前日期-出生日期
  16.         long result=time2-time;
  17.         result=result/1000/60/60/24;
  18.         System.out.println(result);
  19.  
  20.         //JDK8
  21.         LocalDate ld1=new LocalDate.of(2001,12,05);
  22.         LocalDate ld2=new LocalDate.now();
  23.         long days=ChronoUnit.DAYS.between(ld1,ld2);
  24.         System.out.println(days);
  25.     }
  26. }

练习5：判断任意的一个年份是闰年还是平年。

要求：用JDK7和JDK8的两种方式完成

提示：二月有29天是闰年，一年366天是闰年

  1. import java.text.ParseException;
  2. import java.time.LocalDate;
  3. import java.util.Calendar;
  4.  
  5. public class Test {
  6.     public static void main(String[] args) throws ParseException {
  7.         //JDK7
  8.         Calendar c=Calendar.getInstance();
  9.         c.set(2000,2,1);//表示3月1号
  10.         //把日历往前减一天，如果前一天是29就是闰年
  11.         c.add(Calendar.DAY_OF_MONTH,-1);
  12.         int days=c.get(Calendar.DAY_OF_MONTH);
  13.         if (days==29){
  14.             System.out.println("闰年");
  15.         }
  16.         //JDK8
  17.         LocalDate ld=LocalDate.of(2000,3,1);
  18.         LocalDate days1 = ld.minusDays(1);
  19.         int days2=days1.getDayOfMonth();
  20.         //System.out.println(days2);
  21.         if (days2==29){
  22.             System.out.println("闰年");
  23.         }
  24.     }
  25. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/331164
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号