public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> {}

// time 是当前时间，单位是毫秒。

// 它是当前时间距离“January 1, 1970, 0:00:00 GMT”的差值。

protected long time;

// 保存这17个字段的数组

protected int           fields[];

// 数组的定义函数

protected Calendar(TimeZone zone, Locale aLocale)

{

    // 初始化“fields数组”

    fields = new int[FIELD_COUNT];

    isSet = new boolean[FIELD_COUNT];

    stamp = new int[FIELD_COUNT];

    this.zone = zone;

    setWeekCountData(aLocale);

}

public int get(int field) {

    // 计算各个字段的值

    complete();

    // 返回field字段的值

    return internalGet(field);

}

protected void complete()

{

    if (!isTimeSet)

    updateTime();

    if (!areFieldsSet || !areAllFieldsSet) {

        computeFields(); // fills in unset fields

        areAllFieldsSet = areFieldsSet = true;

    }

}

private void updateTime() {

    computeTime();

    isTimeSet = true;

}

protected final int internalGet(int field) {

    return fields[field];

}

// 获取Calendar实例

Calendar cal = Calendar.getInstance();

// 获取MONTH的最大值

int max = cal.getMaximum(Calendar.MONTH);

// 获取Calendar实例

Calendar cal = Calendar.getInstance();

// 获取当前MONTH的最大值

int max = cal.getActualMaximum(Calendar.MONTH);

// 获取Calendar实例

Calendar cal = Calendar.getInstance();

// 获取MONTH的最小值

int min = cal.getMinimum(Calendar.MONTH);

// 获取Calendar实例

Calendar cal = Calendar.getInstance();

// 获取MONTH的最小值

int min = cal.getMinimum(Calendar.MONTH);

// 获取Calendar实例

Calendar cal = Calendar.getInstance();

// 获取“cal日历”的当前MONTH值

int MONTH = cal.get(Calendar.MONTH);

// 获取Calendar实例

Calendar cal = Calendar.getInstance();

// 设置“cal日历”的当前MONTH值为 1988年

cal.set(Calendar.MONTH, 1988);

// 获取Calendar实例，并设置日期为“2013-09-01”

Calendar cal = Calendar.getInstance();

cal.set(Calendar.YEAR, 2013);

cal.set(Calendar.MONTH, 8);

cal.set(Calendar.DATE, 1);

// 给“cal日历”的当前MONTH值 “添加-10”

cal.add(Calendar.MONTH, -10);

// 获取Calendar实例，并设置日期为“2013-09-01”

Calendar cal = Calendar.getInstance();

cal.set(Calendar.YEAR, 2013);

cal.set(Calendar.MONTH, 8);

cal.set(Calendar.DATE, 1);

// 将“cal日历”的当前MONTH值 “向前滚动10”

cal.roll(Calendar.MONTH, -10);

// 获取Calendar实例，并设置日期为“9月”

Calendar cal = Calendar.getInstance();

cal.set(Calendar.MONTH, 9);

// 清空MONTH

cal.clear(Calendar.MONTH);

// 获取Calendar实例

Calendar cal = Calendar.getInstance();

// 判断MONTH是否被设置

boolean bset = cal.isSet(Calendar.MONTH);

// 比较“当前Calendar对象”和“calendar” 的日期、时区等内容是否相等。

boolean equals(Object object)

// 当前Calendar对象 是否 早于calendar

boolean before(Object calendar)

// 当前Calendar对象 是否 晚于calendar

boolean after(Object calendar)

// 比较“当前Calendar对象”和“calendar”。

// 若 早于 “calendar” 则，返回-1

// 若 相等， 则，返回0

// 若 晚于 “calendar” 则，返回1

int compareTo(Calendar anotherCalendar) 

// 它们的使用方法如下

boolean isEqual = cal1.equals(cal2);

boolean isBefore = cal1.before(cal2);

boolean isAfter = cal1.after(cal2);

int icompare = cal1.compareTo(cal2);

// 设置“Calendar的宽容度”

void setLenient(boolean value)

// 获取“Calendar的宽容度”

boolean isLenient()

// 设置“年月日”

final void     set(int year, int month, int day)

// 设置“年月日时分”

final void     set(int year, int month, int day, int hourOfDay, int minute, int second)

// 设置“年月日时分秒”

final void     set(int year, int month, int day, int hourOfDay, int minute)

// 获取Calendar对应的日期

final Date     getTime()

// 设置Calendar为date

final void    setTime(Date date)

// 获取Calendar对应的时区

TimeZone     getTimeZone()

// 设置Calendar对应的时区

void     setTimeZone(TimeZone timezone)

// 获取Calendar对应的milliscondes值，就是“Calendar当前日期”距离“1970-01-01 0:00:00 GMT”的毫秒数

long     getTimeInMillis()

// 设置Calendar对应的milliscondes值

void     setTimeInMillis(long milliseconds)

// 克隆Calendar

Object clone()

// 获取“每周的第一天是星期几”。例如，在美国，这一天是 SUNDAY，而在法国，这一天是 MONDAY。

int getFirstDayOfWeek()

// 设置“每周的第一天是星期几”。例如，在美国，这一天是 SUNDAY，而在法国，这一天是 MONDAY。

void setFirstDayOfWeek(int value)

// 获取一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则此方法将返回 1。如果最少天数必须是一整个星期，则此方法将返回 7。

int getMinimalDaysInFirstWeek()

// 设置一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则使用值 1 调用此方法。如果最少天数必须是一整个星期，则使用值 7 调用此方法。

void setMinimalDaysInFirstWeek(int value)

 import java.util.Date;

 import java.util.Calendar;

 import java.util.TimeZone;

 import java.util.Random;

 /**

  * Calendar的API测试程序

  *

  * @author skywang

  * @email kuiwu-wang@163.com

  */

 public class CalendarTest {

     public static void main(String[] args) {

         // 测试Calendar的“17个字段的公共函数接口”

         testAllCalendarSections() ;

         // 测试Calendar的“比较接口”

         testComparatorAPIs() ;

         // 测试Calendar的“比较接口”

         testLenientAPIs() ;

         // 测试Calendar的Date、TimeZone、MilliSecond等相关函数

         testTimeAPIs() ;

         // 测试Calendar的clone()，getFirstDayOfWeek()等接口

         testOtherAPIs() ;

     }

     /**

      * 测试“Calendar的字段”

      *

      * @param cal   -- Calendar对象

      * @param field -- 要测试的“Calendar字段”。可以为以下值：

      *   Calendar.YEAR, Calendar.MONTH, Calendar.DATE, ... 等等

      * @param title -- 标题

      * @author skywang (kuiwu-wang@163.com)

      */

     private static void testSection(Calendar cal, int field, String title) {

         final Random random = new Random();

         final Date date = cal.getTime();

         final int min = cal.getMinimum(field);    // 获取"字段最小值"

         final int max = cal.getMaximum(field);    // 获取“字段最大值”

         final int actualMin = cal.getActualMinimum(field);    // 获取"当前日期下，该字段最小值"

         final int actualMax = cal.getActualMaximum(field);    // 获取“当前日期下，该字段的最大值”

         // 获取“字段的当前值”

         final int ori = cal.get(field);            

         // 设置“字段的当前值”, 并获取“设置之后的值”

         final int r1 = random.nextInt(max);

         cal.set(field, r1);

         final int set = cal.get(field);

         try {

             // 回滚“字段的当前值”：在“字段最小值”和“字段最大值”之间回滚。

             // “回滚值”可以为正，也可以为负。

             cal.roll(field, -max);

         } catch (IllegalArgumentException e) {

             // 当field == Calendar.ZONE_OFFSET时，会抛出该异常！

             e.printStackTrace();

         }

         final int roll = cal.get(field);            

         // 获取一个随机值

         final int sign = ( random.nextInt(2) == 1) ? 1 : -1;

         final int r2 = sign * random.nextInt(max);

         try {

             // 增加“字段的当前值” ，并获取“新的当前字段值”

             // add的“参数值”可以为正，也可以为负。

             cal.add(field, r2);

         } catch (IllegalArgumentException e) {

             // 当field == Calendar.ZONE_OFFSET时，会抛出该异常！

             e.printStackTrace();

         }

         final int add = cal.get(field);

         // 打印字段信息

         System.out.printf("%s:\n\trange is [%d - %d] actualRange is [%d - %d].  original=%d, set(%d)=%d, roll(%d)=%d, add(%d)=%d\n",

                title, min, max, actualMin, actualMax, ori, r1, set, -max, roll, r2, add);

     }

     /**

      * 测试Calendar的“17个字段的公共函数接口”

      *

      * @author skywang (kuiwu-wang@163.com)

      */

     private static void testAllCalendarSections() {

         // 00. ERA 字段

         testSection(Calendar.getInstance(), Calendar.ERA, "Calendar.ERA");

         // 01. YEAR 字段

         testSection(Calendar.getInstance(), Calendar.YEAR, "Calendar.YEAR");

         // 02. MONTH 字段

         testSection(Calendar.getInstance(), Calendar.MONTH, "Calendar.MONTH");

         // 03. WEEK_OF_YEAR 字段

         testSection(Calendar.getInstance(), Calendar.WEEK_OF_YEAR, "Calendar.WEEK_OF_YEAR");

         // 04. WEEK_OF_MONTH 字段

         testSection(Calendar.getInstance(), Calendar.WEEK_OF_MONTH, "Calendar.WEEK_OF_MONTH");

         // 05. DATE 字段

         testSection(Calendar.getInstance(), Calendar.DATE, "Calendar.DATE");

         // 06. DAY_OF_MONTH 字段

         testSection(Calendar.getInstance(), Calendar.DAY_OF_MONTH, "Calendar.DAY_OF_MONTH");

         // 07. DAY_OF_YEAR 字段

         testSection(Calendar.getInstance(), Calendar.DAY_OF_YEAR, "Calendar.DAY_OF_YEAR");

         // 08. DAY_OF_WEEK 字段

         testSection(Calendar.getInstance(), Calendar.DAY_OF_WEEK, "Calendar.DAY_OF_WEEK");

         // 09. DAY_OF_WEEK_IN_MONTH 字段

         testSection(Calendar.getInstance(), Calendar.DAY_OF_WEEK_IN_MONTH, "Calendar.DAY_OF_WEEK_IN_MONTH");

         // 10. AM_PM 字段

         testSection(Calendar.getInstance(), Calendar.AM_PM, "Calendar.AM_PM");

         // 11. HOUR 字段

         testSection(Calendar.getInstance(), Calendar.HOUR, "Calendar.HOUR");

         // 12. HOUR_OF_DAY 字段

         testSection(Calendar.getInstance(), Calendar.HOUR_OF_DAY, "Calendar.HOUR_OF_DAY");

         // 13. MINUTE 字段

         testSection(Calendar.getInstance(), Calendar.MINUTE, "Calendar.MINUTE");

         // 14. SECOND 字段

         testSection(Calendar.getInstance(), Calendar.SECOND, "Calendar.SECOND");

         // 15. MILLISECOND 字段

         testSection(Calendar.getInstance(), Calendar.MILLISECOND, "Calendar.MILLISECOND");

         // 16. ZONE_OFFSET 字段

         testSection(Calendar.getInstance(), Calendar.ZONE_OFFSET, "Calendar.ZONE_OFFSET");

     }

     /**

      * 测试Calendar的“比较接口”

      *

      * @author skywang (kuiwu-wang@163.com)

      */

     private static void testComparatorAPIs() {

         // 新建cal1 ，且时间为1988年

         Calendar cal1 = Calendar.getInstance();

         cal1.set(Calendar.YEAR, 1988);

         // 新建cal2 ，且时间为2000年

         Calendar cal2 = Calendar.getInstance();

         cal2.set(Calendar.YEAR, 2000);

         // 新建cal3, 为cal1的克隆对象

         Calendar cal3 = (Calendar)cal1.clone();

         // equals 判断 cal1和cal2的“时间、时区等”内容是否相等

         boolean isEqual12 = cal1.equals(cal2);

         // equals 判断 cal1和cal3的“时间、时区等”内容是否相等

         boolean isEqual13 = cal1.equals(cal3);

         // cal1是否比cal2早

         boolean isBefore = cal1.before(cal2);

         // cal1是否比cal2晚

         boolean isAfter = cal1.after(cal2);

         // 比较cal1和cal2

         // (01) 若cal1 早于 cal2，返回-1

         // (02) 若cal1 等于 cal2，返回0

         // (03) 若cal1 晚于 cal2，返回1

         int icompare = cal1.compareTo(cal2);

         System.out.printf("\ntestComparatorAPIs: isEuqal12=%s, isEqual13=%s, isBefore=%s, isAfter=%s, icompare=%s\n",

                isEqual12, isEqual13, isBefore, isAfter, icompare);

     }

     /**

      * 测试Calendar的“比较接口”

      *

      * @author skywang (kuiwu-wang@163.com)

      */

     private static void testLenientAPIs() {

             Calendar cal = Calendar.getInstance();

             // 获取默认的“宽容度”。返回true

             boolean oriLenient = cal.isLenient();

             // MONTH值只能是“0-11”，这里越界。但是由于当前cal是宽容的，所以不会抛出异常

             cal.set(Calendar.MONTH, 50);    

             // 设置“宽容度”为false。

             cal.setLenient(false);

             // 获取设置后的“宽容度”

             boolean curLenient = cal.isLenient();

             try {

             // MONTH值只能是“0-11”，这里越界。而且当前cal是不宽容的，所以会产生异常。

             // 但是，异常到下次计算日期时才会抛出。即，set()中不回抛出异常，而要等到get()中才会抛出异常

             cal.set(Calendar.MONTH, 50);

             // 此时，对cal进行读取。读取会导致重新计算cal的值，所以此时抛出异常！

             int m2 = cal.get(Calendar.MONTH);

         } catch (IllegalArgumentException e) {

             e.printStackTrace();

         }

         System.out.printf("\ntestLenientAPIs: oriLenient=%s, curLenient=%s\n",

                oriLenient, curLenient);

     }

     /**

      * 测试Calendar的Date、TimeZone、MilliSecond等相关函数

      *

      * @author skywang (kuiwu-wang@163.com)

      */

     private static void testTimeAPIs() {

         Calendar cal = Calendar.getInstance();

         // 设置cal的时区为“GMT+8”

         cal.setTimeZone(TimeZone.getTimeZone("GMT+8"));

         // 获取当前的cal时区

         TimeZone timezone = cal.getTimeZone();

         // 设置 milliseconds

         cal.setTimeInMillis(1279419645742l);

         // 获取 milliseconds

         long millis = cal.getTimeInMillis();

         // 设置 milliseconds之后，时间也改变了。

         // 获取cal对应的日期

         Date date = cal.getTime();

         // 设置时间为“1988-08-08”

         cal.set(1988, 08, 08);

         // 设置时间为“1999-09-09 09:09”

         cal.set(1999, 09, 09, 9, 9);

         // 设置时间为“2000-10-10 10:10:10”

         cal.set(2000, 10, 10, 10, 10, 10);

         System.out.printf("\ntestTimeAPIs: date=%s, timezone=%s, millis=%s\n",

                date, timezone, millis);

     }

     /**

      * 测试Calendar的clone()，getFirstDayOfWeek()等接口

      *

      * @author skywang (kuiwu-wang@163.com)

      */

     private static void testOtherAPIs() {

         Calendar cal = Calendar.getInstance();

         // 克隆cal

         Calendar clone = (Calendar)cal.clone();

         // 设置 为 2013-01-10。

         // 注：2013-01-01 为“星期二”，2013-01-06为“星期天”，

         clone.set(Calendar.YEAR, 2013);

         clone.set(Calendar.MONTH, 0);

         clone.set(Calendar.DATE, 10);

         // 设置“本年的第一个星期最少包含1天”。

         // 则2013-01-10属于第2个星期

         clone.setMinimalDaysInFirstWeek(1);

         int m1 = clone.getMinimalDaysInFirstWeek();

         int index1 = clone.get(Calendar.WEEK_OF_YEAR);

         // 设置“本年的第一个星期最少包含7天”。

         // 则2013-01-10属于第1个星期

         clone.setMinimalDaysInFirstWeek(7);

         int m2 = clone.getMinimalDaysInFirstWeek();

         int index2 = clone.get(Calendar.WEEK_OF_YEAR);

         // 设置“每周的第一天是星期几”。

         clone.setFirstDayOfWeek(Calendar.WEDNESDAY);

         // 获取“每周的第一天是星期几”。

         int firstdayOfWeek = clone.getFirstDayOfWeek();

         System.out.printf("\ntestOtherAPIs: firstdayOfWeek=%s, [minimalDay, WeekOfYear]={(%s, %s), (%s, %s)} %s\n",

                firstdayOfWeek, m1, index1, m2, index2, clone.getTime());

     }

 }