Java 基础类库：System、Runtime、Object、Math、日期、时间

与用户互动

运行Java程序的参数

//Java程序入口：main()方法
public static void main(String[] args){...}

• public修饰符：Java类由JVM调用，为了让JVM可以自由调用这个main()方法，所以使用public修饰符把这个方法暴露出来

• static修饰符：JVM调用这个主方法时，不会先创建该主类的对象，然后通过对象来调用该主方法。JVM直接通过该类来调用主方法，因此使用static修饰该主方法。

• void返回值：因为主方法被JVM调用，该方法的返回值将返回给JVM，因此main()方法没有返回值。

使用Scanner获取键盘输入

使用Scanner类可以很方便地获取用户的键盘输入，Scanner是一个基于正则表达式的文本扫描器，可以从文件、输入流、字符串中解析出基本类型值和字符串值。

Scanner主要提供了两个方法来扫描输入

• hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果只是判断是否包含下一个字符串，则直接使用hasNext()

• nextXxx()：获取下一个输入项。

默认情况下，Scanner使用空白（空格、Tab空白、回车）作为多个输入项之间的分隔符。

import java.util.Scanner;

public class ScannerKeyBoardTest 
{
    public static void main(String[] args) 
    {
        //System.in代表标准输入，就是键盘输入
        Scanner sc = new Scanner(System.in);
        //增加下面一行将只把回车作为分隔符
        //sc.useDelimiter("\n");
        //判断是否还有下一个输入项
        while (sc.hasNext()) 
        {
            //输出输入项
            System.out.println("键盘输入的内容是："+ sc.next());
        }
    }
}

Scanner提供了两个简单的方法来逐行读取

• boolean hasNextLine()：返回输入源中是否还有下一行

• String nextLine()：返回输入源中下一行的字符串

创建Scanner对象，传入一个File对象作为参数，程序将读取ScannerFileTest.java文件中的内容

import java.io.File;
import java.util.Scanner;

public class ScannerFileTest 
{
    public static void main(String[] args) throws Exception
    {
        //将一个File对象作为Scanner的构造器参数，Scanner读取文件内容
        Scanner sc = new Scanner(new File("ScannerFileTest.java"));
        System.out.println("ScannerFileTest.java文件内容如下：");
        //判断是否还有下一行
        while (sc.hasNextLine()) 
        {
            //输出文件中的下一行
            System.out.println(sc.nextLine());
        }
    }
}  

系统相关

System类

System类代表了当前Java程序的运行平台，程序不能创建System类的对象，System类提供了一些类变量和类方法，允许直接通过System类来调用这些类变量和类方法。

加载文件和动态链接库主要对naive方法有用，对于一些特殊的功能（如访问操作系统底层硬件设备等）Java程序无法实现必须借助C语音来完成，此时需要使用C语音为Java方法提供实现

1. Java程序中声明native修饰的方法，类似于abstract方法，只有方法签名，没有实现。编译该Java程序，生成一个class文件

2. 用javah编译第1步生成的class文件，将生成一个.h文件

3. 写一个.cpp文件实现native，这一步需要包含第2步生成的.h文件（.h文件中包含JDK带的jni.h文件）

4. 将第3步的.cpp文件编译成动态链接库文件

5. 在Java中用System类的loadLibrary..()方法或Runtime类的loadLibrary()方法加载第4步产生的动态链接库文件，Java程序中就可以调用这个native方法了。

import java.io.FileOutputStream;
import java.util.Map;
import java.util.Properties;

public class SystemTest 
{
    public static void main(String[] args) throws Exception
    {
        //获取系统所有的环境变量
        Map<String, String> env = System.getenv();
        for(String name : env.keySet())
        {
            System.out.println(name + " ---> " + env.get(name));
        }
        //获取指定环境变量的值
        System.out.println(System.getenv("JAVA_HOME"));
        //获取所有的系统属性
        Properties properties = System.getProperties();
        //将所有的系统属性保存到properties.txt文件中
        properties.store(new FileOutputStream("properties.txt"), "System Properties");
        //输出特定的系统属性
        System.out.println(System.getProperty("os.name"));
    }
}

System类的in、out和err分别代表系统的标准输入（通常是键盘）、标准输出（通常是显示器）和错误输出流，并提供了setIn()、setOut()和setErr()方法

identityHashCode(Object x)方法，该方法返回指定对象的精确hashCode值，也就是根据该对象的地址计算得到的hashCode值。如果两个对象的identityHashCode值相同，则两个对象绝对是同一个对象。

public class IdentityHashCodeTest 
{
    public static void main(String[] args) 
    {
        //下面程序中s1和s2是两个不同的对象
        String s1 = new String("Hello");
        String s2 = new String("Hello");
        //String重写了hashCode()方法——改为根据字符序列计算hashCode值
        //因为s1和s2的字符序列相同，所有它们的hashCode()方法返回值相同
        System.out.println(s1.hashCode() + "---" + s2.hashCode());
        //s1和s2是不同的字符串对象，所以它们的identityHashCode值不同
        System.out.println(System.identityHashCode(s1) + "---" + System.identityHashCode(s2));
        String s3 = "Java";
        String s4 = "Java";
        //s3和s4是相同的字符串对象，所以它们的identityHashCode值相同
        System.out.println(System.identityHashCode(s3) + "---" + System.identityHashCode(s4));
    }
}

Runtime类

Runtime类代表Java程序的运行时环境，可以访问JVM的相关信息，如处理器数量、内存信息等。每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。应用程序不能创建自己的Runtime实例，但可以通过getRuntime()方法获取与之关联的Runtime对象。

Runtime类提供gc()方法和runFinalization()方法来通知系统进行垃圾回收、清理系统资源，并提供了load(String filename)和loadLibrary(String libname)方法来加载文件和动态链接库。

public class ExecTest 
{
    public static void main(String[] args) throws Exception
    {
        //获取Java程序关联的运行时对象
        Runtime runtime = Runtime.getRuntime();
        System.out.println("处理器数量：" + runtime.availableProcessors());
        System.out.println("空闲内存数：" + runtime.freeMemory());
        System.out.println("总内存数：" + runtime.totalMemory());
        System.out.println("可用最大内存数" + runtime.maxMemory());
        //运行记事本程序
        runtime.exec("notepad.exe");
    }
}

常用类

Object类

Object类是所有类、数组、枚举类的父类，Java允许把任何类型的对象赋给Object类型的变量。

• boolean equals(Object obj)：判断指定对象与该对象是否相等

• protected void finalize()：当系统中没有引用变量引用到该对象时，垃圾回收器调用该方法来清理该对象的资源

• Class<?>getClass()：返回该对象的运行时类

• int hashCode()：返回该对象的hashCode()值

• String toString()：返回该对象的字符串表示，当程序使用System.out.println()方法输出一个对象，或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的toString()方法返回该对象的字符串表示。

Java提供protected修饰的clone()方法，用于帮助其他对象来实现“自我克隆”，需要被子类重写或调用。

自定义类实现“克隆”的步骤

1. 自定义类实现Cloneable接口

2. 自定义实现自己的clone()方法

3. 实现clone()方法时通过super.clone();调用Object实现的clone()方法来得到该对象的副本，并返回该副本。

class Address
{
    String detail;
    public Address(String detail)
    {
        this.detail =detail;
    }
}
//实现Cloneable接口
class User implements Cloneable
{
    int age;
    Address address;
    public User(int age)
    {
        this.age = age;
        address = new Address("珠江新城");
    }
    //通过调用super.clone()来实现clone()方法
    public User clone() throws CloneNotSupportedException
    {
        return (User)(super.clone());
    }
}
public class CloneTest
{
    public static void main(String[] args) throws CloneNotSupportedException
    {
        User u1 = new User(27);
        //clone得到u1对象的副本
        User u2 = u1.clone();
        //判断u1、u2是否相同
        System.out.println(u1 == u2);
        //判断u1、u2的address是否相同
        System.out.println(u1.address == u2.address);
    }
}

Java7新增的Object类

如果不能确定一个引用变量是否为null，如果贸然地调用该变量的toString()方法，则可能引发NullPointerException异常；如果使用Object类提供的toString(Object o)方法，就不会引发空指针异常，当o为null时，程序将返回一个"null"字符串。

Java为工具类的命名习惯是添加一个字母s，比如操作数组的工具类Arrays，操作集合的工具类Collections。

import java.util.Objects;
public class ObjectsTest 
{
    //定义一个objectsTest变量，它的默认值是null
    static ObjectsTest objectsTest;
    public static void main(String[] args) 
    {
        //输出一个null对象的hashCode值，输出0
        System.out.println(Objects.hashCode(objectsTest));
        //输出一个null对象的toString，输出null
        System.out.println(Objects.toString(objectsTest));
        //要求objectsTest不能为null，如果objectsTest为null
        System.out.println(Objects.requireNonNull(objectsTest,"objectsTest参数不能是null!"));
    }
}

requireNonNull()方法，当传入的参数不为null时，该方法返回参数本身；否则将会引发NullPointerException异常。

Math类

构造器被定义成private的，因此无法参加Math类的对象，所有方法都是类方法，可以直接通过类名来调用它们，还提供了两个类变量：PI和E

public class MathTest
{
    public static void main(String[] args)
    {
        /*---------下面是三角运算---------*/
        // 将弧度转换角度
        System.out.println("Math.toDegrees(1.57)："
            + Math.toDegrees(1.57));
        // 将角度转换为弧度
        System.out.println("Math.toRadians(90)："
            + Math.toRadians(90));
        // 计算反余弦，返回的角度范围在 0.0 到 pi 之间。
        System.out.println("Math.acos(1.2)：" + Math.acos(1.2));
        // 计算反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
        System.out.println("Math.asin(0.8)：" + Math.asin(0.8));
        // 计算反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
        System.out.println("Math.atan(2.3)：" + Math.atan(2.3));
        // 计算三角余弦。
        System.out.println("Math.cos(1.57)：" + Math.cos(1.57));
        // 计算值的双曲余弦。
        System.out.println("Math.cosh(1.2 )：" + Math.cosh(1.2 ));
        // 计算正弦
        System.out.println("Math.sin(1.57 )：" + Math.sin(1.57 ));
        // 计算双曲正弦
        System.out.println("Math.sinh(1.2 )：" + Math.sinh(1.2 ));
        // 计算三角正切
        System.out.println("Math.tan(0.8 )：" + Math.tan(0.8 ));
        // 计算双曲正切
        System.out.println("Math.tanh(2.1 )：" + Math.tanh(2.1 ));
        // 将矩形坐标 (x, y) 转换成极坐标 (r, thet));
        System.out.println("Math.atan2(0.1, 0.2)：" + Math.atan2(0.1, 0.2));
        /*---------下面是取整运算---------*/
        // 取整，返回小于目标数的最大整数。
        System.out.println("Math.floor(-1.2 )：" + Math.floor(-1.2 ));
        // 取整，返回大于目标数的最小整数。
        System.out.println("Math.ceil(1.2)：" + Math.ceil(1.2));
        // 四舍五入取整
        System.out.println("Math.round(2.3 )：" + Math.round(2.3 ));
        /*---------下面是乘方、开方、指数运算---------*/
        // 计算平方根。
        System.out.println("Math.sqrt(2.3 )：" + Math.sqrt(2.3 ));
        // 计算立方根。
        System.out.println("Math.cbrt(9)：" + Math.cbrt(9));
        // 返回欧拉数 e 的n次幂。
        System.out.println("Math.exp(2)：" + Math.exp(2));
        // 返回 sqrt(x2 +y2)
        System.out.println("Math.hypot(4 , 4)：" + Math.hypot(4 , 4));
        // 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
        System.out.println("Math.IEEEremainder(5 , 2)："
            + Math.IEEEremainder(5 , 2));
        // 计算乘方
        System.out.println("Math.pow(3, 2)：" + Math.pow(3, 2));
        // 计算自然对数
        System.out.println("Math.log(12)：" + Math.log(12));
        // 计算底数为 10 的对数。
        System.out.println("Math.log10(9)：" + Math.log10(9));
        // 返回参数与 1 之和的自然对数。
        System.out.println("Math.log1p(9)：" + Math.log1p(9));
        /*---------下面是符号相关的运算---------*/
        // 计算绝对值。
        System.out.println("Math.abs(-4.5)：" + Math.abs(-4.5));
        // 符号赋值，返回带有第二个浮点数符号的第一个浮点参数。
        System.out.println("Math.copySign(1.2, -1.0)："
            + Math.copySign(1.2, -1.0));
        // 符号函数；如果参数为 0，则返回 0；如果参数大于 0，
        // 则返回 1.0；如果参数小于 0，则返回 -1.0。
        System.out.println("Math.signum(2.3)：" + Math.signum(2.3));
        /*---------下面是大小相关的运算---------*/
        // 找出最大值
        System.out.println("Math.max(2.3 , 4.5)：" + Math.max(2.3 , 4.5));
        // 计算最小值
        System.out.println("Math.min(1.2 , 3.4)：" + Math.min(1.2 , 3.4));
        // 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
        System.out.println("Math.nextAfter(1.2, 1.0)："
            + Math.nextAfter(1.2, 1.0));
        // 返回比目标数略大的浮点数
        System.out.println("Math.nextUp(1.2 )：" + Math.nextUp(1.2 ));
        // 返回一个伪随机数，该值大于等于 0.0 且小于 1.0。
        System.out.println("Math.random()：" + Math.random());
    }
}

Java 7的ThreadLocalRandom与Random

Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子（当前时间作为种子），另一个构造器需要程序员显式传入一个long型整数的种子

ThreadLocalRandom类是Java7新增的一个类，在并发访问环境下，可以减少多线程资源竞争，最终保证系统具有更好的线程安全性。提供静态的current()方法来获取ThreadLocalRandom对象，获取该对象之后调用各种nextXxx()方法来获取伪随机数

import java.util.Arrays;
import java.util.Random;

public class RandomTest 
{
    public static void main(String[] args) 
    {
        Random random = new Random();
        System.out.println("random.nextBoolean():"+random.nextBoolean());
        byte[] buffer = new byte[16];
        random.nextBytes(buffer);
        System.out.println(Arrays.toString(buffer));
        //生成0.0~1.0之间的伪随机double数
        System.out.println("random.nextDouble():"+random.nextDouble());
        //生成0.0~1.0之间的伪随机float数
        System.out.println("random.nextFloat():"+random.nextFloat());
        //生成平均值是0.0，标准差是1.0的伪高斯数
        System.out.println("random.nextGaussian():"+random.nextGaussian());
        //生成0~26之间的伪随机整数
        System.out.println("random.nextInt(26):"+random.nextInt(26));
        //生成一个处于long整数取值范围的伪随机整数
        System.out.println("random.nextLong():"+random.nextLong());
    }
}

Random使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，对它们以同样的顺序调用方法，则它们会产生相同的数字序列。为避免两个Random对象产生相同的数字序列，推荐使用当前时间作为Random对象的种子

Random rt = new Random(System.currentTimeMillis());

ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
//生成一个4~20之间的伪随机整数
int vall = threadLocalRandom.nextInt(4, 20);
//生成一个2.0~10.0之间的伪随机浮点数
int vall2 = threadLocalRandom.nextDouble(2.0, 10.0);

BigDecimal类

BigDecimal能精确表示、计算浮点数。该类提供了大量的构造器用于创建BigDecimal对象，包括把所有基本数值型变量转换成一个BigDecimal对象，也包括利用数字字符串、数字字符数组来创建BigDecimal对象。

BigDecimal(String val)构造器的结果是可预知的——写入new BigDecimal("0.1")将创建一个BigDecimal对象，优先建议使用基于String的构造器

如果必须使用double浮点数作为BigDecimal构造器的参数时， 不要直接将该double浮点数作为构造器参数创建BigDecimal对象，而是通过BigDecimal.valueOf(double calue)静态方法来创建BigDecimal对象

Java8的日期、时间类

Date类

Date()：生成一个代表当前日期的Date对象
Date(long date)：根据指定的long型整数来生成一个Date对象
boolean after(Date when)：测试该日期是否在指定日期when之后
boolean before(Date when)：测试该日期是否在指定日期when之前
long getTime()：返回该时间对应的long型整数，即从GMT 1970-01-01 00:00:00到该Date对象之间的时间差，以毫秒为计时单位
void setTime()：设置该Date对象的时间

Calendar类

Calendar类是一个抽象类，所以不能使用构造器来创建Calendar对象。但它提供了几个静态getInstance()方法来获取Calendar对象，这些方法根据TimeZone，Locale类来获取特定的Calendar

Calendar类提供了大量访问、修改日期时间的方法

• void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量

• int get(int field)：返回给定日历字段的值

• int getActualMaximum(int field)：返回指定日历字段可能拥有的最大值

• int getActualMinimum(int field)：返回指定日历字段可能拥有的最小值

• void roll(int field, int amount)：向指定日历字段添加指定（有符号的）时间量，不更改更大的字段

• void set(int field, int value)：将给定的日历字段设置为给定值

• void set(int year, int month, int date)：设置日历字段年、月、日的值

• void set(int year, int month, int date, int hourOfDay, int minute)：设置日历字段年、月、日、时、分、秒的值。

public class CalendarTest
{
    public static void main(String[] args)
    {
        Calendar c = Calendar.getInstance();
        // 取出年
        System.out.println(c.get(YEAR));
        // 取出月份
        System.out.println(c.get(MONTH));
        // 取出日
        System.out.println(c.get(DATE));
        // 分别设置年、月、日、小时、分钟、秒
        c.set(2003 , 10 , 23 , 12, 32, 23); //2003-11-23 12:32:23
        System.out.println(c.getTime());
        // 将Calendar的年前推1年
        c.add(YEAR , -1); //2002-11-23 12:32:23
        System.out.println(c.getTime());
        // 将Calendar的月前推8个月
        c.roll(MONTH , -8); //2002-03-23 12:32:23
        System.out.println(c.getTime());

        Calendar cal1 = Calendar.getInstance();
        cal1.set(2003, 7, 23, 0, 0 , 0); // 2003-8-23
        cal1.add(MONTH, 6); //2003-8-23 => 2004-2-23
        System.out.println(cal1.getTime());

        Calendar cal2 = Calendar.getInstance();
        cal2.set(2003, 7, 31, 0, 0 , 0); // 2003-8-31
        // 因为进位到后月份改为2月，2月没有31日，自动变成29日
        cal2.add(MONTH, 6); // 2003-8-31 => 2004-2-29
        System.out.println(cal2.getTime());

        Calendar cal3 = Calendar.getInstance();
        cal3.set(2003, 7, 23, 0, 0 , 0); //2003-8-23
        // MONTH字段“进位”，但YEAR字段并不增加
        cal3.roll(MONTH, 6); //2003-8-23 => 2003-2-23
        System.out.println(cal3.getTime());

        Calendar cal4 = Calendar.getInstance();
        cal4.set(2003, 7, 31, 0, 0 , 0); //2003-8-31
        // MONTH字段“进位”后变成2，2月没有31日，
        // YEAR字段不会改变，2003年2月只有28天
        cal4.roll(MONTH, 6); //2003-8-31 => 2003-2-28
        System.out.println(cal4.getTime());
    }
}

add与roll的区别

add(int field, int amount)

• 当被修改的字段超过它允许的范围时，会发生进位，即上一级字段会增大

• 如果下一级字段也需要改变，那么该字段会修正到变化最小的值

roll当被修改的字段超过它允许的范围时，上一级字段不会增大，下一级字段的处理规则与add相似

Calendar的容错性

public class LenientTest
{
    public static void main(String[] args)
    {
        Calendar cal = Calendar.getInstance();
        // 结果是YEAR字段加1，MONTH字段为1（二月）
        cal.set(MONTH , 13);   //①
        System.out.println(cal.getTime());
        // 关闭容错性
        cal.setLenient(false);
        // 导致运行时异常
        cal.set(MONTH , 13);   //②
        System.out.println(cal.getTime());
    }
}

①代码可以正常运行，YEAR字段加1；②代码将会导致运行时异常，因为设置MONTH字段超出了MONTH字段允许的范围。Calendar提供了一个setLenient()用于设置它的容错性，Calendar默认支持较好的容错性，通过setLenient(false)可以关闭Calendar的容错性，让它严格的参数检查。

Java8新增的日期、时间包

• Clock：该类用于获取指定时间的当前的日期、时间。该类可取代System类的currentTimeMillis()方法，而且提供了更多方法来获取当前日期、时间。该类提供了大量静态方法来获取Clock对象

• Duration:该类代表持续的时间

• Instant：代表一个具体的时刻，可以精确到纳秒。提供了静态now()方法来获取当前时刻，也提供了静态的now(Clock clock)方法来获取clock对应的时刻。minusXxx()和plusXxx()方法在当前时刻的基础上减去/加上一段时间

• LocalDate：该类代表不带时区的日期。供了静态的now(Clock clock)方法来获取clock对应的日期。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几年、几月、几周或几日

• LocalTime：该类代表不带时区的时间。供了静态的now(Clock clock)方法来获取clock对应的时间。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几小时、几分、几秒等

• LocalDateTime：该类代表不带时区的日期、时间。供了静态的now(Clock clock)方法来获取clock对应的时间、日期。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几年、几月、几周、几日、几小时、几分、几秒等

• MonthDay：该类仅表示月日。提供了静态的now(Clock clock)方法

• Year：该类仅表示年。提供了静态的now(Clock clock)方法。minusYears()和plusYears()方法
  -YearMonth：该类仅代表年月。提供了静态的now(Clock clock)方法，minusXxx()和plusXxx()方法

• ZonedDatetime：该类代表一个时区化的日期、时间

• ZoneId：该类代表一个时区

• DayofWeek：这是一个枚举类周一到周六的枚举

• Mouth：该类也是一个枚举类，定义一月到十二月的枚举值

  public class NewDatePackageTest
  {

  public static void main(String[] args)
  {
      // -----下面是关于Clock的用法-----
      // 获取当前Clock
      Clock clock = Clock.systemUTC();
      // 通过Clock获取当前时刻
      System.out.println("当前时刻为：" + clock.instant());
      // 获取clock对应的毫秒数，与System.currentTimeMillis()输出相同
      System.out.println(clock.millis());
      System.out.println(System.currentTimeMillis());
      // -----下面是关于Duration的用法-----
      Duration d = Duration.ofSeconds(6000);
      System.out.println("6000秒相当于" + d.toMinutes() + "分");
      System.out.println("6000秒相当于" + d.toHours() + "小时");
      System.out.println("6000秒相当于" + d.toDays() + "天");
      // 在clock基础上增加6000秒，返回新的Clock
      Clock clock2 = Clock.offset(clock, d);
      // 可看到clock2与clock1相差1小时40分
      System.out.println("当前时刻加6000秒为：" +clock2.instant());
      // -----下面是关于Instant的用法-----
      // 获取当前时间
      Instant instant = Instant.now();
      System.out.println(instant);
      // instant添加6000秒（即100分钟），返回新的Instant
      Instant instant2 = instant.plusSeconds(6000);
      System.out.println(instant2);
      // 根据字符串中解析Instant对象
      Instant instant3 = Instant.parse("2014-02-23T10:12:35.342Z");
      System.out.println(instant3);
      // 在instant3的基础上添加5小时4分钟
      Instant instant4 = instant3.plus(Duration
          .ofHours(5).plusMinutes(4));
      System.out.println(instant4);
      // 获取instant4的5天以前的时刻
      Instant instant5 = instant4.minus(Duration.ofDays(5));
      System.out.println(instant5);
      // -----下面是关于LocalDate的用法-----
      LocalDate localDate = LocalDate.now();
      System.out.println(localDate);
      // 获得2014年的第146天
      localDate = LocalDate.ofYearDay(2014, 146);
      System.out.println(localDate); // 2014-05-26
      // 设置为2014年5月21日
      localDate = LocalDate.of(2014, Month.MAY, 21);
      System.out.println(localDate); // 2014-05-21
      // -----下面是关于LocalTime的用法-----
      // 获取当前时间
      LocalTime localTime = LocalTime.now();
      // 设置为22点33分
      localTime = LocalTime.of(22, 33);
      System.out.println(localTime); // 22:33
      // 返回一天中的第5503秒
      localTime = LocalTime.ofSecondOfDay(5503);
      System.out.println(localTime); // 01:31:43
      // -----下面是关于localDateTime的用法-----
      // 获取当前日期、时间
      LocalDateTime localDateTime = LocalDateTime.now();
      // 当前日期、时间加上25小时３分钟
      LocalDateTime future = localDateTime.plusHours(25).plusMinutes(3);
      System.out.println("当前日期、时间的25小时3分之后：" + future);
      // 下面是关于Year、YearMonth、MonthDay的用法示例-----
      Year year = Year.now(); // 获取当前的年份
      System.out.println("当前年份：" + year); // 输出当前年份
      year = year.plusYears(5); // 当前年份再加5年
      System.out.println("当前年份再过5年：" + year);
      // 根据指定月份获取YearMonth
      YearMonth ym = year.atMonth(10);
      System.out.println("year年10月：" + ym); // 输出XXXX-10，XXXX代表当前年份
      // 当前年月再加5年，减3个月
      ym = ym.plusYears(5).minusMonths(3);
      System.out.println("year年10月再加5年、减3个月：" + ym);
      MonthDay md = MonthDay.now();
      System.out.println("当前月日：" + md); // 输出--XX-XX，代表几月几日
      // 设置为5月23日
      MonthDay md2 = md.with(Month.MAY).withDayOfMonth(23);
      System.out.println("5月23日为：" + md2); // 输出--05-23
  }

  }