摘要：類提供方法和方法來通知系統進行垃圾回收清理系統資源，并提供了和方法來加載文件和動態鏈接庫。返回按照標準的規定，對兩個參數進行余數運算。

//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主要提供了兩個方法來掃描輸入

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("
");
        //判斷是否還有下一個輸入項
        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類代表了當前Java程序的運行平臺，程序不能創建System類的對象，System類提供了一些類變量和類方法，允許直接通過System類來調用這些類變量和類方法。

加載文件和動態鏈接庫主要對naive方法有用，對于一些特殊的功能（如訪問操作系統底層硬件設備等）Java程序無法實現必須借助C語音來完成，此時需要使用C語音為Java方法提供實現

Java程序中聲明native修飾的方法，類似于abstract方法，只有方法簽名，沒有實現。編譯該Java程序，生成一個class文件

用javah編譯第1步生成的class文件，將生成一個.h文件

寫一個.cpp文件實現native，這一步需要包含第2步生成的.h文件（.h文件中包含JDK帶的jni.h文件）

將第3步的.cpp文件編譯成動態鏈接庫文件

在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 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類代表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類是所有類、數組、枚舉類的父類，Java允許把任何類型的對象賦給Object類型的變量。

boolean equals(Object obj)：判斷指定對象與該對象是否相等

protected void finalize()：當系統中沒有引用變量引用到該對象時，垃圾回收器調用該方法來清理該對象的資源

ClassgetClass()：返回該對象的運行時類

int hashCode()：返回該對象的hashCode()值

String toString()：返回該對象的字符串表示，當程序使用System.out.println()方法輸出一個對象，或者把某個對象和字符串進行連接運算時，系統會自動調用該對象的toString()方法返回該對象的字符串表示。

Java提供protected修飾的clone()方法，用于幫助其他對象來實現“自我克隆”，需要被子類重寫或調用。

自定義類實現“克隆”的步驟

自定義類實現Cloneable接口

自定義實現自己的clone()方法

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

如果不能確定一個引用變量是否為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異常。

構造器被定義成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());
    }
}

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(String val)構造器的結果是可預知的——寫入new BigDecimal("0.1")將創建一個BigDecimal對象，優先建議使用基于String的構造器

如果必須使用double浮點數作為BigDecimal構造器的參數時， 不要直接將該double浮點數作為構造器參數創建BigDecimal對象，而是通過BigDecimal.valueOf(double calue)靜態方法來創建BigDecimal對象

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對象。但它提供了幾個靜態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(int field, int amount)

當被修改的字段超過它允許的范圍時，會發生進位，即上一級字段會增大

如果下一級字段也需要改變，那么該字段會修正到變化最小的值

roll當被修改的字段超過它允許的范圍時，上一級字段不會增大，下一級字段的處理規則與add相似

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的容錯性，讓它嚴格的參數檢查。

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
}

}