模块 java.base
包 java.time

类 Year

java.lang.Object
java.time.Year
所有已实现的接口：
Serializable , Comparable<Year> , Temporal , TemporalAccessor , TemporalAdjuster
public final class Year extends Object implements Temporal , TemporalAdjuster , Comparable <Year >, Serializable
ISO-8601 日历系统中的年份，例如 2007 。

Year 是代表年份的不可变日期时间对象。可以得到任何可以从年份导出的字段。

请注意，ISO 年表中的年份仅与现代格里高利 - 朱利安系统中的年份一致。直到 1920 年，俄罗斯部分地区才改用现代公历/ISO 规则。因此，必须谨慎对待历史年份。

此类不存储或表示月、日、时间或时区。例如，值“2007”可以存储在 Year 中。

此类代表的年份遵循 ISO-8601 标准并使用预编号系统。第 1 年之前是第 0 年，然后是第 -1 年。

ISO-8601 日历系统是当今世界大部分地区使用的现代民用日历系统。它相当于公历系统，在所有时间都适用今天的闰年规则。对于当今编写的大多数应用程序，ISO-8601 规则完全适用。然而，任何使用历史日期并要求它们准确的应用程序都会发现 ISO-8601 方法不合适。

这是一个value-based类；程序员应该将 equal 的实例视为可互换的，并且不应使用实例进行同步，否则可能会发生不可预测的行为。例如，在未来的版本中，同步可能会失败。 equals 方法应该用于比较。

实现要求：
这个类是不可变的和线程安全的。
自从：
1.8
参见：

  • 字段详细信息

    • MIN_VALUE

      public static final int MIN_VALUE
      支持的最小年份“-999,999,999”。
      参见：

    • MAX_VALUE

      public static final int MAX_VALUE
      支持的最大年份，“+999,999,999”。
      参见：

  • 方法详情

    • now

      public static Year  now()
      从默认时区的系统时钟获取当前年份。

      这将查询默认时区中的 system clock 以获取当前年份。

      使用此方法将阻止使用备用时钟进行测试的能力，因为时钟是硬编码的。

      返回：
      使用系统时钟和默认时区的当前年份，不为空

    • now

      public static Year  now(ZoneId  zone)
      从指定时区的系统时钟获取当前年份。

      这将查询 system clock 以获取当前年份。指定时区避免了对默认时区的依赖。

      使用此方法将阻止使用备用时钟进行测试的能力，因为时钟是硬编码的。

      参数：
      zone - 要使用的区域 ID，不为空
      返回：
      使用系统时钟的当前年份，不为空

    • now

      public static Year  now(Clock  clock)
      从指定时钟获取当前年份。

      这将查询指定的时钟以获取当前年份。使用此方法允许使用备用时钟进行测试。可以使用 dependency injection 引入备用时钟。

      参数：
      clock - 使用的时钟，不为空
      返回：
      当前年份，不为空

    • of

      public static Year  of(int isoYear)
      获得 Year 的实例。

      此方法接受来自 proleptic ISO 日历系统的年份值。

      公元 2 年/公元 2 年用 2 表示。
      公元 1 年/公元 1 年用 1 表示。
      1BC/BCE 年份用 0 表示。
      2BC/BCE 年用-1 表示。

      参数：
      isoYear - 要表示的 ISO 预测年份，从 MIN_VALUE 到 MAX_VALUE
      返回：
      年份，不为空
      抛出：
      DateTimeException - 如果字段无效

    • from

      public static Year  from(TemporalAccessor  temporal)
      从时间对象中获取 Year 的实例。

      这将根据指定的时间获取年份。 TemporalAccessor 表示一组任意的日期和时间信息，该工厂将其转换为 Year 的一个实例。

      转换提取 year 字段。仅当时间对象具有 ISO 年表或可以转换为 LocalDate 时才允许提取。

      此方法与功能接口 TemporalQuery 的签名相匹配，允许它通过方法参考 Year::from 用作查询。

      参数：
      temporal - 要转换的时间对象，不为空
      返回：
      年份，不为空
      抛出：
      DateTimeException - 如果无法转换为 Year

    • parse

      public static Year  parse(CharSequence  text)
      从 2007 等文本字符串中获取 Year 的实例。

      该字符串必须代表有效年份。

      参数：
      text - 要解析的文本，例如“2007”，不为空
      返回：
      解析的年份，不为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • parse

      public static Year  parse(CharSequence  text, DateTimeFormatter  formatter)
      使用特定格式化程序从文本字符串中获取 Year 的实例。

      使用格式化程序解析文本，返回年份。

      参数：
      text - 要解析的文本，不为空
      formatter - 要使用的格式化程序，不为空
      返回：
      解析的年份，不为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • isLeap

      public static boolean isLeap(long year)
      根据 ISO proleptic 日历系统规则，检查年份是否为闰年。

      此方法在整个时间线上应用当前的闰年规则。一般来说，如果年份可以被四整除而没有余数，则为闰年。但是，能被 100 整除的年份不是闰年，但能被 400 整除的年份除外。

      例如，1904 是闰年，它可以被 4 整除。1900 不是闰年，因为它可以被 100 整除，但是 2000 是闰年，因为它可以被 400 整除。

      计算是有前瞻性的——将相同的规则应用到遥远的未来和遥远的过去。这在历史上是不准确的，但对于 ISO-8601 标准是正确的。

      参数：
      year - 要检查的年份
      返回：
      如果年份是闰年则为 true，否则为 false

    • getValue

      public int getValue()
      获取年份值。

      根据 get(YEAR)，此方法返回的年份是预估的。

      返回：
      这一年，MIN_VALUE 到 MAX_VALUE

    • isSupported

      public boolean isSupported(TemporalField  field)
      检查是否支持指定的字段。

      这将检查是否可以针对指定字段查询今年。如果为 false，则调用 range 、get 和 with(TemporalField, long) 方法将抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。支持的字段是：

      • YEAR_OF_ERA
      • YEAR
      • ERA
      所有其他 ChronoField 实例将返回 false。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.isSupportedBy(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。字段是否支持由字段决定。

      指定者：
      isSupported 在接口 TemporalAccessor 中
      参数：
      field - 要检查的字段，null 返回 false
      返回：
      如果今年支持该字段，则为 true，否则为 false

    • isSupported

      public boolean isSupported(TemporalUnit  unit)
      检查是否支持指定的单位。

      这将检查指定的单位是否可以添加到今年或从中减去。如果为 false，则调用 plus(long, TemporalUnit) 和 minus 方法将抛出异常。

      如果单位是ChronoUnit 那么查询就是在这里实现的。支持的单位有：

      • YEARS
      • DECADES
      • CENTURIES
      • MILLENNIA
      • ERAS
      所有其他 ChronoUnit 实例将返回 false。

      如果单位不是 ChronoUnit ，则通过调用 TemporalUnit.isSupportedBy(Temporal) 传递 this 作为参数来获得此方法的结果。是否支持该单元由单元决定。

      指定者：
      isSupported 在接口 Temporal 中
      参数：
      unit - 要检查的单位，null 返回 false
      返回：
      如果可以添加/减去单位，则为 true，否则为 false

    • range

      public ValueRange  range(TemporalField  field)
      获取指定字段的有效值范围。

      范围对象表示字段的最小和最大有效值。今年用于增强返回范围的准确性。如果由于不支持该字段或其他原因而无法返回范围，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将返回适当的范围实例。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.rangeRefinedBy(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取范围由字段决定。

      指定者：
      range 在接口 TemporalAccessor 中
      参数：
      field - 查询范围的字段，不为空
      返回：
      该字段的有效值范围，不为空
      抛出：
      DateTimeException - 如果无法获得该字段的范围
      UnsupportedTemporalTypeException - 如果不支持该字段

    • get

      public int get(TemporalField  field)
      从今年获取指定字段的值作为 int 。

      这将查询今年指定字段的值。返回值将始终在该字段的有效值范围内。如果由于不支持该字段或其他原因而无法返回该值，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将返回基于今年的有效值。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.getFrom(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取到该值，该值代表什么，由字段决定。

      指定者：
      get 在接口 TemporalAccessor 中
      参数：
      field - 要获取的字段，不为空
      返回：
      该字段的值
      抛出：
      DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值范围
      UnsupportedTemporalTypeException - 如果不支持该字段或值的范围超过 int
      ArithmeticException - 如果发生数字溢出

    • getLong

      public long getLong(TemporalField  field)
      获取今年指定字段的值作为 long 。

      这将查询今年指定字段的值。如果由于不支持该字段或其他原因而无法返回该值，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将返回基于今年的有效值。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.getFrom(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取到该值，该值代表什么，由字段决定。

      指定者：
      getLong 在接口 TemporalAccessor 中
      参数：
      field - 要获取的字段，不为空
      返回：
      该字段的值
      抛出：
      DateTimeException - 如果无法获得该字段的值
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数字溢出

    • isLeap

      public boolean isLeap()
      根据 ISO proleptic 日历系统规则，检查年份是否为闰年。

      此方法在整个时间线上应用当前的闰年规则。一般来说，如果年份可以被四整除而没有余数，则为闰年。但是，能被 100 整除的年份不是闰年，但能被 400 整除的年份除外。

      例如，1904 是闰年，它可以被 4 整除。1900 不是闰年，因为它可以被 100 整除，但是 2000 是闰年，因为它可以被 400 整除。

      计算是有前瞻性的——将相同的规则应用到遥远的未来和遥远的过去。这在历史上是不准确的，但对于 ISO-8601 标准是正确的。

      返回：
      如果年份是闰年则为 true，否则为 false

    • isValidMonthDay

      public boolean isValidMonthDay(MonthDay  monthDay)
      检查今年的月日是否有效。

      此方法检查今年和输入的月份和日期是否构成有效日期。

      参数：
      monthDay - 要验证的月-日，null 返回 false
      返回：
      如果月份和日期在今年有效，则为真

    • length

      public int length()
      获取今年的天数。
      返回：
      今年的天数，365 或 366

    • with

      public Year  with(TemporalAdjuster  adjuster)
      返回今年的调整副本。

      这将返回一个 Year ，基于这个，并调整了年份。使用指定的调整器策略对象进行调整。阅读调整器的文档以了解将进行的调整。

      此方法的结果是通过在指定的调节器上调用 TemporalAdjuster.adjustInto(Temporal) 方法并将 this 作为参数传递来获得的。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      with 在接口 Temporal 中
      参数：
      adjuster - 要使用的调节器，不为空
      返回：
      a Year 基于 this 并进行了调整，不为空
      抛出：
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数字溢出

    • with

      public Year  with(TemporalField  field, long newValue)
      返回今年的副本，并将指定字段设置为新值。

      这将返回一个 Year ，基于这个，指定字段的值已更改。如果无法设置该值，因为不支持该字段或出于其他原因，则会抛出异常。

      如果该字段是 ChronoField 则在此处执行调整。支持的字段行为如下：

      • YEAR_OF_ERA - 返回具有指定年份的 Year 时代将保持不变。
      • YEAR - 返回具有指定年份的 Year。这完全取代了日期，相当于 of(int) 。
      • ERA - 返回具有指定纪元的 Year。纪元年将保持不变。

      在所有情况下，如果新值超出该字段的有效值范围，则会抛出 DateTimeException。

      所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.adjustInto(Temporal, long) 传递 this 作为参数来获得此方法的结果。在这种情况下，该字段决定是否以及如何调整瞬间。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      with 在接口 Temporal 中
      参数：
      field - 要在结果中设置的字段，不为空
      newValue - 结果中字段的新值
      返回：
      基于 this 的 Year 具有指定的字段集，不为空
      抛出：
      DateTimeException - 如果无法设置字段
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数字溢出

    • plus

      public Year  plus(TemporalAmount  amountToAdd)
      返回添加了指定数量的今年的副本。

      这将返回一个 Year ，基于这个，添加了指定的数量。数量通常是 Period 但可以是实现 TemporalAmount 接口的任何其他类型。

      通过调用 TemporalAmount.addTo(Temporal) 将计算委托给金额对象。金额实现可以自由地以任何它希望的方式实现加法，但是它通常会回调 plus(long, TemporalUnit) 。查阅amount实现的文档，判断是否可以添加成功。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      plus 在接口 Temporal 中
      参数：
      amountToAdd - 添加的数量，不为空
      返回：
      a Year 基于今年的添加，不为空
      抛出：
      DateTimeException - 如果无法添加
      ArithmeticException - 如果发生数字溢出

    • plus

      public Year  plus(long amountToAdd, TemporalUnit  unit)
      返回添加了指定数量的今年的副本。

      这将返回一个 Year ，基于这个，以添加的单位表示数量。如果由于不支持该单位或其他原因而无法添加金额，则会抛出异常。

      如果该字段是ChronoUnit ，则在此处实现加法。支持的字段行为如下：

      • YEARS - 返回添加了指定年数的 Year。这相当于 plusYears(long) 。
      • DECADES - 返回一个 Year 添加了指定的十进制数。这相当于用金额乘以 10 调用 plusYears(long) 。
      • CENTURIES - 返回添加了指定世纪数的 Year。这相当于用金额乘以 100 调用 plusYears(long) 。
      • MILLENNIA - 返回一个 Year 添加了指定的千年数。这相当于用金额乘以 1,000 调用 plusYears(long) 。
      • ERAS - 返回添加了指定纪元数的 Year。仅支持两个纪元，因此数量必须为一、零或负一。如果金额不为零，则年份会发生变化，因此时代年份不变。

      所有其他 ChronoUnit 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoUnit ，则通过调用 TemporalUnit.addTo(Temporal, long) 传递 this 作为参数来获得此方法的结果。在这种情况下，该单元确定是否以及如何执行加法。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      plus 在接口 Temporal 中
      参数：
      amountToAdd - 添加到结果的单位数量，可能为负数
      unit - 添加量的单位，不为空
      返回：
      a Year 基于今年加上指定数量，不为空
      抛出：
      DateTimeException - 如果无法添加
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • plusYears

      public Year  plusYears(long yearsToAdd)
      返回此 Year 的副本，并添加了指定的年数。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      yearsToAdd - 添加的年份，可能为负
      返回：
      Year 基于今年加上年份，不为空
      抛出：
      DateTimeException - 如果结果超出支持的范围

    • minus

      public Year  minus(TemporalAmount  amountToSubtract)
      返回减去指定数量的今年的副本。

      这将返回一个 Year ，基于这个，减去指定的数量。数量通常是 Period 但可以是实现 TemporalAmount 接口的任何其他类型。

      通过调用 TemporalAmount.subtractFrom(Temporal) 将计算委托给金额对象。金额实现可以自由地以任何它希望的方式实现减法，但是它通常会回调 minus(long, TemporalUnit) 。查阅 amount 实现的文档以确定是否可以成功减去。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要减去的金额，不为空
      返回：
      a Year 基于今年的减法，不为空
      抛出：
      DateTimeException - 如果无法进行减法
      ArithmeticException - 如果发生数字溢出

    • minus

      public Year  minus(long amountToSubtract, TemporalUnit  unit)
      返回减去指定数量的今年的副本。

      这将返回一个 Year ，基于这个，减去单位数量。如果无法减去金额，因为不支持该单位或出于其他原因，则会抛出异常。

      此方法等同于 plus(long, TemporalUnit) 取反金额。有关加法和减法如何工作的完整描述，请参阅该方法。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要从结果中减去的单位数量，可能为负数
      unit - 要减去的金额的单位，不为空
      返回：
      a Year 基于今年减去指定金额，不为空
      抛出：
      DateTimeException - 如果无法进行减法
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • minusYears

      public Year  minusYears(long yearsToSubtract)
      返回此 Year 的副本，并减去指定的年数。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      yearsToSubtract - 要减去的年份，可能为负数
      返回：
      Year 基于今年减去年份，不为空
      抛出：
      DateTimeException - 如果结果超出支持的范围

    • query

      public <R> R query(TemporalQuery <R> query)
      今年使用指定查询查询。

      这查询今年使用指定的查询策略对象。 TemporalQuery 对象定义了用于获取结果的逻辑。阅读查询文档以了解此方法的结果。

      此方法的结果是通过对指定查询调用 TemporalQuery.queryFrom(TemporalAccessor) 方法并将 this 作为参数传递来获得的。

      指定者：
      query 在接口 TemporalAccessor 中
      类型参数：
      R - 结果的类型
      参数：
      query - 要调用的查询，不为空
      返回：
      查询结果，可能返回null（由查询定义）
      抛出：
      DateTimeException - 如果无法查询（由查询定义）
      ArithmeticException - 如果发生数字溢出（由查询定义）

    • adjustInto

      public Temporal  adjustInto(Temporal  temporal)
      将指定的时间对象调整为具有今年。

      这将返回一个与输入相同的可观察类型的时间对象，并将年份更改为与此相同。

      调整相当于使用Temporal.with(TemporalField, long) 传递ChronoField.YEAR 作为字段。如果指定的时间对象不使用 ISO 日历系统，则抛出 DateTimeException。

      在大多数情况下，使用 Temporal.with(TemporalAdjuster) 反转调用模式会更清楚：

        // these two lines are equivalent, but the second approach is recommended
  temporal = thisYear.adjustInto(temporal);
  temporal = temporal.with(thisYear);

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      adjustInto 在接口 TemporalAdjuster 中
      参数：
      temporal - 要调整的目标对象，不为空
      返回：
      调整后的对象，不为空
      抛出：
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数字溢出

    • until

      public long until(Temporal  endExclusive, TemporalUnit  unit)
      根据指定的单位计算到另一年的时间量。

      这根据单个 TemporalUnit 计算两个 Year 对象之间的时间量。起点和终点是this和指定的年份。如果结束早于开始，结果将为负。传递给此方法的 Temporal 使用 from(TemporalAccessor) 转换为 Year。例如，可以使用 startYear.until(endYear, DECADES) 计算两年之间以十年为单位的金额。

      计算返回一个整数，表示两年之间的完整单位数。例如，2012 年至 2031 年之间的几十年数量将只有一个十年，因为它比两个十年少一年。

      有两种等效的方法可以使用此方法。第一个是调用这个方法。第二种是使用 TemporalUnit.between(Temporal, Temporal) ：

        // these two lines are equivalent
  amount = start.until(end, YEARS);
  amount = YEARS.between(start, end);
      应该根据哪个使代码更具可读性来做出选择。

      ChronoUnit 的计算在此方法中实现。支持单位 YEARS、DECADES、CENTURIES、MILLENNIA 和 ERAS。其他 ChronoUnit 值将引发异常。

      如果单位不是 ChronoUnit ，则通过调用 TemporalUnit.between(Temporal, Temporal) 将 this 作为第一个参数并将转换后的输入时间作为第二个参数来获得此方法的结果。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      until 在接口 Temporal 中
      参数：
      endExclusive - 结束日期，独占，转换为 Year ，不为空
      unit - 衡量数量的单位，不为空
      返回：
      今年和年底之间的时间量
      抛出：
      DateTimeException - 如果无法计算金额，或者结束时间无法转换为 Year
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • format

      public String  format(DateTimeFormatter  formatter)
      今年使用指定的格式化程序格式化。

      今年将传递给格式化程序以产生一个字符串。

      参数：
      formatter - 要使用的格式化程序，不为空
      返回：
      格式化的年份字符串，不为空
      抛出：
      DateTimeException - 如果在打印过程中发生错误

    • atDay

      public LocalDate  atDay(int dayOfYear)
      将今年与一年中的某一天结合起来创建一个 LocalDate 。

      这将返回从今年和指定日期形成的 LocalDate。

      日期值 366 仅在闰年有效。

      参数：
      dayOfYear - 使用的日期，从 1 到 365-366
      返回：
      从今年开始形成的本地日期和年份的指定日期，不为空
      抛出：
      DateTimeException - 如果一年中的第几天为零或更小，366 或更大或等于 366 并且这不是闰年

    • atMonth

      public YearMonth  atMonth(Month  month)
      将今年与一个月结合起来创建一个YearMonth。

      这将返回从今年和指定月份形成的 YearMonth。年份和月份的所有可能组合均有效。

      此方法可用作链的一部分来生成日期：

       LocalDate date = year.atMonth(month).atDay(day);
      参数：
      month - 使用的月份，不为空
      返回：
      从今年和指定月份形成的年月，不为空

    • atMonth

      public YearMonth  atMonth(int month)
      将今年与一个月结合起来创建一个YearMonth。

      这将返回从今年和指定月份形成的 YearMonth。年份和月份的所有可能组合均有效。

      此方法可用作链的一部分来生成日期：

       LocalDate date = year.atMonth(month).atDay(day);
      参数：
      month - 使用的月份，从 1（一月）到 12（十二月）
      返回：
      从今年和指定月份形成的年月，不为空
      抛出：
      DateTimeException - 如果月份无效

    • atMonthDay

      public LocalDate  atMonthDay(MonthDay  monthDay)
      将今年与月-日结合起来创建一个 LocalDate 。

      这将返回从今年和指定月日形成的 LocalDate。

      如果年份不是闰年，结果日期中的 2 月 29 日将调整为 2 月 28 日。

      参数：
      monthDay - 使用的月日，不为空
      返回：
      从今年和指定的月日形成的本地日期，不为空

    • compareTo

      public int compareTo(Year  other)
      将今年与另一年进行比较。

      比较基于年份的值。正如 Comparable 所定义的那样，它“与等于一致”。

      指定者：
      compareTo 在接口 Comparable<Year> 中
      参数：
      other - 要比较的另一年，不为空
      返回：
      比较值，小于则为负，大于则为正

    • isAfter

      public boolean isAfter(Year  other)
      检查今年是否在指定年份之后。
      参数：
      other - 要比较的另一年，不为空
      返回：
      如果这是在指定年份之后，则为真

    • isBefore

      public boolean isBefore(Year  other)
      检查今年是否在指定年份之前。
      参数：
      other - 要比较的另一年，不为空
      返回：
      如果这一点在指定年份之前，则为真

    • equals

      public boolean equals(Object  obj)
      检查今年是否等于另一年。

      比较是基于年份的时间线位置。

      重写：
      equals 在类 Object 中
      参数：
      obj - 要检查的对象，null 返回 false
      返回：
      如果这等于另一年，则为真
      参见：

    • hashCode

      public int hashCode()
      今年的哈希码。
      重写：
      hashCode 在类 Object 中
      返回：
      合适的哈希码
      参见：

    • toString

      public String  toString()
      今年的输出为 String 。
      重写：
      toString 在类 Object 中
      返回：
      今年的字符串表示形式，不为空