Year (Java Platform SE 8 )

java.lang.Object
- java.time.Year

All Implemented Interfaces:

Serializable， Comparable < Year >， Temporal， TemporalAccessor， TemporalAdjuster
```
public final class Year
extends Object
implements Temporal, TemporalAdjuster, Comparable<Year>, Serializable
```
在ISO-8601日历系统一年，如 2007。
Year是不变的日期时间对象，代表一年。可以得到一年可以得到的任何字段。

值得注意的是，在ISO年表年才符合现代年阳历年朱利安系统。俄罗斯的部分没有切换到现代公历/ ISO规则直到1920。因此，历史上的几年必须谨慎对待。

这个类不存储或表示一个月、一天、时间或时区。例如，值“2007”可以被存储在一个Year。

这类表示年跟随ISO-8601标准和使用预期的编号系统。1年前0年，然后是一年- 1。

该系统是现代民法ISO-8601日历日历系统中使用的大多数今天的世界。它相当于proleptic公历闰年的系统，在今天的规则适用于所有的时间。今天的大多数应用程序编写的，完全适合的ISO-8601规则。然而，任何应用程序，利用历史数据，并要求他们要准确找到ISO-8601方法不当。

这是一个value-based类；利用身份敏感的操作（包括引用相等（==），身份的哈希代码，或同步）的实例Year可能有不可预知的结果应该是可以避免的。的equals法进行比较。

实现要求：

这个类是不可变的和线程安全的。

从以下版本开始：

一点八

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`MAX_VALUE` 最大支持的一年，“999999999”。
`static int`	`MIN_VALUE` 最低支持的一年，“- 999999999”。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象，以有今年。
`LocalDate`	`atDay(int dayOfYear)` 结合今年一年创造一个 `LocalDate`。
`YearMonth`	`atMonth(int month)` 结合今年一个月创造一个 `YearMonth`。
`YearMonth`	`atMonth(Month month)` 结合今年一个月创造一个 `YearMonth`。
`LocalDate`	`atMonthDay(MonthDay monthDay)` 结合今年一个月一天创造一个 `LocalDate`。
`int`	`compareTo(Year other)` 今年比另一年。
`boolean`	`equals(Object obj)` 检查今年是否等于另一年。
`String`	`format(DateTimeFormatter formatter)` 今年使用指定的格式的格式。
`static Year`	`from(TemporalAccessor temporal)` 获得 `Year`实例从一个时空对象。
`int`	`get(TemporalField field)` 获取指定字段的值从今年作为一个 `int`。
`long`	`getLong(TemporalField field)` 获取指定字段的值从今年作为一个 `long`。
`int`	`getValue()` 获取一年值。
`int`	`hashCode()` 今年的哈希代码。
`boolean`	`isAfter(Year other)` 是今年指定的一年后。
`boolean`	`isBefore(Year other)` 是今年前指定的一年。
`boolean`	`isLeap()` 检查，如果今年是闰年，根据ISO预期历法系统规则。
`static boolean`	`isLeap(long year)` 检查，如果今年是闰年，根据ISO预期历法系统规则。
`boolean`	`isSupported(TemporalField field)` 检查指定字段是否被支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否被支持。
`boolean`	`isValidMonthDay(MonthDay monthDay)` 检查本月日是否有效。
`int`	`length()` 获取这一年的长度。
`Year`	`minus(long amountToSubtract, TemporalUnit unit)` 以指定的金额减去该年的副本。
`Year`	`minus(TemporalAmount amountToSubtract)` 以指定的金额减去该年的副本。
`Year`	`minusYears(long yearsToSubtract)` 返回今年的副本，用指定的年数减去。
`static Year`	`now()` 从默认时区中的系统时钟获取当前年份。
`static Year`	`now(Clock clock)` 从指定的时钟获取当前年份。
`static Year`	`now(ZoneId zone)` 从指定时区中的系统时钟获取当前年份。
`static Year`	`of(int isoYear)` 获得 `Year`实例。
`static Year`	`parse(CharSequence text)` 获得 `Year`实例从一个文本字符串，如 `2007`。
`static Year`	`parse(CharSequence text, DateTimeFormatter formatter)` 获得 `Year`实例从使用特定格式的文本字符串。
`Year`	`plus(long amountToAdd, TemporalUnit unit)` 返回一个今年的副本与指定的金额添加。
`Year`	`plus(TemporalAmount amountToAdd)` 返回一个今年的副本与指定的金额添加。
`Year`	`plusYears(long yearsToAdd)` 返回本年的副本，添加指定的年数。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询使用本年查询。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`String`	`toString()` 作为今年的 `String`输出。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 计算时间的数量，直到指定的单位计算一年。
`Year`	`with(TemporalAdjuster adjuster)` 返回今年调整后的副本。
`Year`	`with(TemporalField field, long newValue)` 将今年的副本与指定的字段设置为一个新值。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - MIN_VALUE
```
public static final int MIN_VALUE
```
    最低支持的一年，“- 999999999”。
    
    另请参见：
    
    Constant Field Values
  - MAX_VALUE
```
public static final int MAX_VALUE
```
    最大支持的一年，“999999999”。
    
    另请参见：
    
    Constant Field Values
- 方法详细信息
  - 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实例。
    这个方法接受从预期ISO历法一年的价值。
    
    今年的2.
    2AD / CE是今年1ad / CE是由今年年1.
    1Bc代表一年的0.
    2BC年代表由-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)
```
    获得 Year实例从一个文本字符串，如 2007。
    该字符串必须代表一个有效的一年。年在范围0000到9999必须加上正负符号。
    
    参数
    
    text -解析如“2007”的文字，不为空
    
    结果
    
    解析的一年，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - parse
```
public static Year parse(CharSequence text,
                         DateTimeFormatter formatter)
```
    获得 Year实例从使用特定格式的文本字符串。
    文字使用格式化程序解析，返回的一年。
    
    参数
    
    text -解析文本，不空
    
    formatter -格式化程序使用，不为空
    
    结果
    
    解析的一年，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - isLeap
```
public static boolean isLeap(long year)
```
    检查，如果今年是闰年，根据ISO预期历法系统规则。
    此方法适用于在整个时间线的当前规则的跨越式。一般来说，一年是闰年，如果它能被四整除而没有余数。然而，年100整除，不是闰年，以400的年分的例外。
    
    例如，1904是一个闰年是能被4整除。1900不是一个闰年为100是可分的，但是2000是一个闰年为400是可分的。
    
    计算预期的规则应用到遥远的未来和遥远的过去。这是不准确的，但正确的ISO-8601标准。
    
    参数
    
    year -年度检查
    
    结果
    
    如果一年是跳跃的，否则是错误的
  - 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，然后通过调用作为参数传递this TemporalField.isSupportedBy(TemporalAccessor)得到此方法的结果。是否支持字段由字段确定。
    Specified by:
    
    isSupported 接口 TemporalAccessor
    
    参数
    
    field -现场检查null返回false
    
    结果
    
    如果这一领域在今年得到了支持，那是假的，如果不是
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否被支持。
    此检查如果指定的单位可以添加到或减去，这个日期时间。如果为false，则调用plus(long, TemporalUnit)和minus方法将抛出一个异常。
    
    如果单位是一个ChronoUnit然后查询执行。所支持的单位是：
    - YEARS
    - DECADES
    - CENTURIES
    - MILLENNIA
    - ERAS
    所有其他 ChronoUnit实例将返回false。
    如果单位不ChronoUnit，然后通过调用作为参数传递this TemporalUnit.isSupportedBy(Temporal)得到此方法的结果。是否支持单位是由单位确定的。
    Specified by:
    
    isSupported 接口 Temporal
    
    参数
    
    unit -检查单元，空返回false
    
    结果
    
    如果单位可以增加/减去，如果没有的话
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    该范围对象表示字段的最小值和最大有效值。今年是用来提高返回范围的准确性。如果它是不可能返回的范围，因为字段不支持或其他一些原因，抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将返回适当的范围的情况下。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.rangeRefinedBy(TemporalAccessor)得到此方法的结果。是否可以得到范围是由字段确定的。
    
    Specified by:
    
    range 接口 TemporalAccessor
    
    参数
    
    field -现场查询范围，不为空
    
    结果
    
    字段的有效值的范围，而不是空值
    
    异常
    
    DateTimeException如果不能得到的领域范围
    
    UnsupportedTemporalTypeException如果字段不支持
  - get
```
public int get(TemporalField field)
```
    获取指定字段的值从今年作为一个 int。
    此查询今年为指定字段的值。返回的值将始终在字段的有效值范围内。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于今年的有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    get 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果字段的值是不能获得或值不在字段的有效值范围内
    
    UnsupportedTemporalTypeException -如果字段不支持或值的范围超过一个 int
    
    ArithmeticException如果数值溢出时
  - getLong
```
public long getLong(TemporalField field)
```
    获取指定字段的值从今年作为一个 long。
    此查询今年为指定字段的值。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于今年的有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    getLong 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果不能得到一个价值领域
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - isLeap
```
public boolean isLeap()
```
    检查，如果今年是闰年，根据ISO预期历法系统规则。
    此方法适用于在整个时间线的当前规则的跨越式。一般来说，一年是闰年，如果它能被四整除而没有余数。然而，年100整除，不是闰年，以400的年分的例外。
    
    例如，1904是一个闰年是能被4整除。1900不是一个闰年为100是可分的，但是2000是一个闰年为400是可分的。
    
    计算预期的规则应用到遥远的未来和遥远的过去。这是不准确的，但正确的ISO-8601标准。
    
    结果
    
    如果一年是跳跃的，否则是错误的
  - isValidMonthDay
```
public boolean isValidMonthDay(MonthDay monthDay)
```
    检查本月日是否有效。
    这种方法检查是否今年和输入月和日形成一个有效日期。
    
    参数
    
    monthDay -月日证实，空返回false
    
    结果
    
    如果一个月和一天是有效的，今年是正确的
  - length
```
public int length()
```
    获取这一年的长度。
    
    结果
    
    这一年的长度，365或366
  - with
```
public Year with(TemporalAdjuster adjuster)
```
    返回今年调整后的副本。
    这将返回一个Year，基于此，与去年的调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    一个 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，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    一个 Year基于指定的字段集 this，不空
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - plus
```
public Year plus(TemporalAmount amountToAdd)
```
    返回一个今年的副本与指定的金额添加。
    这将返回一个Year，在此基础上，用指定的添加量。量通常是Period但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.addTo(Temporal)数量，实现免费在任何情况下它的愿望实现，但是它通常称为回plus(long, TemporalUnit)。咨询量的执行文件以确定它是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加量，不为空
    
    结果
    
    加上今年 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添加。这相当于用金额乘以1000呼叫plusYears(long)。
    - ERAS返回具有指定数量的时代Year添加。只有两个时代是支持的，所以金额必须是一个，零或负一个。如果金额为非零，则年是改变的，这样的时代是不变的。
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoUnit，然后通过调用作为参数传递this TemporalUnit.addTo(Temporal, long)得到此方法的结果。在这种情况下，该单元确定是否和如何执行加法。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -单位的数量增加的结果，可能是负面的
    
    unit -量的单位添加，不为空
    
    结果
    
    用指定的添加量在今年的一 Year为主，不为空
    
    异常
    
    DateTimeException如果还不能
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - plusYears
```
public Year plusYears(long yearsToAdd)
```
    返回本年的副本，添加指定的年数。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    yearsToAdd -加年，可能是负面的
    
    结果
    
    以期增加今年 Year为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持时间范围
  - minus
```
public Year minus(TemporalAmount amountToSubtract)
```
    以指定的金额减去该年的副本。
    这将返回一个Year，在此基础上，用指定的金额减去。量通常是Period但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.subtractFrom(Temporal)数量，实现自由以任何方式希望实现减法，但它通常需要回minus(long, TemporalUnit)。咨询文档的量的实现，以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    用减法，在今年 Year为主，不为空
    
    异常
    
    DateTimeException如果减法不能做
    
    ArithmeticException如果数值溢出时
  - minus
```
public Year minus(long amountToSubtract,
                  TemporalUnit unit)
```
    以指定的金额减去该年的副本。
    这将返回一个Year，在此基础上，对单位金额减去。如果它是不可能的减去的量，因为该单位不支持或一些其他原因，一个异常被抛出。
    
    这种方法是相当的金额plus(long, TemporalUnit)否定。见该方法充分说明了如何加法，从而减法，作品。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去从结果数额的单位，可能是负面的
    
    unit -金额单位减，不为空
    
    结果
    
    用指定的金额减去今年 Year为主，不为空
    
    异常
    
    DateTimeException如果减法不能做
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - minusYears
```
public Year minusYears(long yearsToSubtract)
```
    返回今年的副本，用指定的年数减去。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    yearsToSubtract -减去年，可能是负面的
    
    结果
    
    以期在今年 Year减去基础，不为空
    
    异常
    
    DateTimeException -如果结果超过支持时间范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询使用本年查询。
    此查询使用指定的查询策略对象使用。的TemporalQuery对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象，以有今年。
    这将返回一个相同的可观察类型的时间对象，与一年的输入改变是相同的。
    
    调整是相当于用Temporal.with(TemporalField, long)传递ChronoField.YEAR作为现场。如果指定的时间对象不使用ISO的日历系统，然后DateTimeException抛出。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间=今年adjustinto（时间）；时间=时间，（今年）；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    计算时间的数量，直到指定的单位计算一年。
    这两Year计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定的年。结果将是负的，如果结束之前开始。的Temporal传递给此方法转换为Year使用from(TemporalAccessor)。例如，两年年期可计算startYear.until(endYear, DECADES)。
    
    计算返回一个整数，表示两个年之间的完全单位数。例如，在几十年的2012至2031年间，将只有一个十年，因为它是一年短短的二十年。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用TemporalUnit.between(Temporal, Temporal)：
```
这两条线是等价的金额=开始，直到（结束，年）；金额=年之间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法ChronoUnit。单位YEARS，DECADES，CENTURIES，MILLENNIA和ERAS支持。其他ChronoUnit值将抛出一个异常。
    
    如果单位不ChronoUnit，然后通过调用TemporalUnit.between(Temporal, Temporal) this作为第一个参数传递和转换的输入时间作为第二个参数给出了这个方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    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 -每年使用一天，不为空
    
    结果
    
    从今年形成的本地日期和年份的指定日期，而不是空
    
    异常
    
    DateTimeException如果每年的这一天是零或更少，366或大于或等于366，这不是一个闰年
  - atMonth
```
public YearMonth atMonth(Month month)
```
    结合今年一个月创造一个 YearMonth。
    这将返回一个YearMonth从今年形成指定的月份。年和月的所有可能的组合都是有效的。
    
    此方法可以作为链的一部分，以产生一个日期：
```
localdate日期=年。atmonth（月）。atday（天）；
```
    参数
    
    month -年月使用，不为空
    
    结果
    
    从今年和指定月份形成的一年，而不是零
  - atMonth
```
public YearMonth atMonth(int month)
```
    结合今年一个月创造一个 YearMonth
    这将返回一个YearMonth从今年形成指定的月份。年和月的所有可能的组合都是有效的。
    
    此方法可以作为链的一部分，以产生一个日期：
```
localdate日期=年。atmonth（月）。atday（天）；
```
    。
    参数
    
    month -年月使用，从1（一月）到12（十二月）
    
    结果
    
    从今年和指定月份形成的一年，而不是零
    
    异常
    
    DateTimeException -如果一个月无效
  - atMonthDay
```
public LocalDate atMonthDay(MonthDay monthDay)
```
    结合今年一个月一天创造一个 LocalDate。
    这将返回一个LocalDate从今年形成指定的月日。
    
    2月29日的一个月天将调整到2月28日，如果一年不是一个飞跃。
    
    参数
    
    monthDay -月日使用，不为空
    
    结果
    
    当地日期从今年和指定的一个月天，而不是空
  - compareTo
```
public int compareTo(Year other)
```
    今年比另一年。
    该比较是基于一年的价值。这是“等于”一致，所定义的Comparable。
    
    Specified by:
    
    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 -检查对象，空返回false
    
    结果
    
    这是真的，如果这是等于另一年
    
    另请参见：
    
    Object.hashCode()， HashMap
  - hashCode
```
public int hashCode()
```
    今年的哈希代码。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    一个合适的哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    作为今年的 String输出。
    
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    一个今年的字符串表示形式，不是空的

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Year

Field Summary

方法摘要

Methods inherited from class java.lang.Object

Field Detail

MIN_VALUE

MAX_VALUE

方法详细信息

now

now

now

of

from

parse

parse

isLeap

getValue

isSupported

isSupported

range

get

getLong

isLeap

isValidMonthDay

length

with

with

plus

plus

plusYears

minus

minus

minusYears

query

adjustInto

until

format

atDay

atMonth

atMonth

atMonthDay

compareTo

isAfter

isBefore

equals

hashCode

toString