All Implemented Interfaces:

Serializable ， Comparable<YearMonth> ， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class YearMonth
extends Object
implements Temporal, TemporalAdjuster, Comparable<YearMonth>, Serializable
```
在ISO- 2007-12 ，如2007-12 。
YearMonth是一个不变的日期时间对象，表示一年和一个月的组合。可以获得可以从年和月派生的任何字段，例如四分之一年份。

此类不存储或表示一天，时间或时区。例如，值“2007年10月”可以存储在YearMonth 。

ISO-8601日历系统是当今世界绝大多数的现代民用日历系统。它相当于今天的闰年规则一直适用于日常生活的公历日历系统。对于今天写的大多数应用，ISO-8601规则是完全合适的。然而，任何利用历史日期并要求它们准确的应用程序都将发现ISO-8601方法不合适。

这是一个value-based类; 在YearMonth实例上使用身份敏感操作（包括引用等式（ == ），身份哈希码或同步）可能会产生不可预测的结果，应该避免。 equals方法应用于比较。

实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`Temporal`	`adjustInto(Temporal temporal)`	将指定的时间对象调整为今年。
`LocalDate`	`atDay(int dayOfMonth)`	结合今年的月份，创造一个 `LocalDate` 。
`LocalDate`	`atEndOfMonth()`	在月底返回 `LocalDate` 。
`int`	`compareTo(YearMonth other)`	比较今年至另一个月。
`boolean`	`equals(Object obj)`	检查这个年月是否等于另一个一个月。
`String`	`format(DateTimeFormatter formatter)`	使用指定的格式化程序在今年的格式。
`static YearMonth`	`from(TemporalAccessor temporal)`	从时间对象获取一个 `YearMonth`的实例。
`int`	`get(TemporalField field)`	从这个月份获取指定字段的值作为 `int` 。
`long`	`getLong(TemporalField field)`	从这个月份获取指定字段的值作为 `long` 。
`Month`	`getMonth()`	使用 `Month`枚举获取月份字段。
`int`	`getMonthValue()`	将月份字段从1到12。
`int`	`getYear()`	获取年份字段。
`int`	`hashCode()`	今年的哈希码。
`boolean`	`isAfter(YearMonth other)`	检查这个年月是否在指定的年月之后。
`boolean`	`isBefore(YearMonth other)`	检查这个年月是否在指定的年份之前。
`boolean`	`isLeapYear()`	根据ISO培训日历系统规则，检查年份是否是闰年。
`boolean`	`isSupported(TemporalField field)`	检查指定的字段是否受支持。
`boolean`	`isSupported(TemporalUnit unit)`	检查指定的单位是否受支持。
`boolean`	`isValidDay(int dayOfMonth)`	检查月日是否在今年有效。
`int`	`lengthOfMonth()`	返回月份的长度，考虑到年份。
`int`	`lengthOfYear()`	返回一年的长度。
`YearMonth`	`minus(long amountToSubtract, TemporalUnit unit)`	返回减去指定数量的今年的副本。
`YearMonth`	`minus(TemporalAmount amountToSubtract)`	返回减去指定数量的今年的副本。
`YearMonth`	`minusMonths(long monthsToSubtract)`	返回此 `YearMonth`的副本，并减去指定的月数。
`YearMonth`	`minusYears(long yearsToSubtract)`	返回此 `YearMonth`的副本，并减去指定的年数。
`static YearMonth`	`now()`	从默认时区的系统时钟获取当前的一个月。
`static YearMonth`	`now(Clock clock)`	从指定的时钟获取当前的一个月。
`static YearMonth`	`now(ZoneId zone)`	从指定时区的系统时钟获取当前的一个月。
`static YearMonth`	`of(int year, int month)`	从一年和一个月获得 `YearMonth`的实例。
`static YearMonth`	`of(int year, Month month)`	从一个月和一个月获得一个 `YearMonth`的实例。
`static YearMonth`	`parse(CharSequence text)`	从 `2007-12`等文本字符串获取 `YearMonth`的实例。
`static YearMonth`	`parse(CharSequence text, DateTimeFormatter formatter)`	使用特定的格式化程序从文本字符串获取 `YearMonth`的实例。
`YearMonth`	`plus(long amountToAdd, TemporalUnit unit)`	返回此年份的副本，并添加指定的金额。
`YearMonth`	`plus(TemporalAmount amountToAdd)`	返回此年份的副本，并添加指定的金额。
`YearMonth`	`plusMonths(long monthsToAdd)`	返回此 `YearMonth`的副本，并附加指定的月数。
`YearMonth`	`plusYears(long yearsToAdd)`	返回此 `YearMonth`的副本，并附加指定的年数。
`<R> R`	`query(TemporalQuery<R> query)`	使用指定的查询查询今年。
`ValueRange`	`range(TemporalField field)`	获取指定字段的有效值的范围。
`String`	`toString()`	今年产量为 `String` ，如 `2007-12` 。
`long`	`until(Temporal endExclusive, TemporalUnit unit)`	根据指定单位计算直到另一个一个月的时间量。
`YearMonth`	`with(TemporalAdjuster adjuster)`	返回今年的调整副本。
`YearMonth`	`with(TemporalField field, long newValue)`	返回此年月份的副本，并将指定的字段设置为新值。
`YearMonth`	`withMonth(int month)`	返回这个 `YearMonth`的副本， `YearMonth`日更改。
`YearMonth`	`withYear(int year)`	返回此 `YearMonth`的副本。

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

- 方法详细信息
  - now
```
public static YearMonth now()
```
    从默认时区的系统时钟获取当前的一个月。
    这将查询默认时区中的system clock以获取当前的年月。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    结果
    
    当前年份使用系统时钟和默认时区，不为空
  - now
```
public static YearMonth now(ZoneId zone)
```
    从指定时区的系统时钟获取当前的一个月。
    这将查询system clock获取当前的一个月。指定时区可以避免对默认时区的依赖。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    参数
    
    zone - 要使用的区域ID，不为空
    
    结果
    
    当前年份使用系统时钟，不为空
  - now
```
public static YearMonth now(Clock clock)
```
    从指定的时钟获取当前的一个月。
    这将查询指定的时钟以获取当前的年月。使用此方法可以使用备用时钟进行测试。可以使用dependency injection引入备用时钟。
    
    参数
    
    clock - 要使用的时钟，不为空
    
    结果
    
    当年，不为零
  - of
```
public static YearMonth of(int year,
                           Month month)
```
    从一年和一个月获得 YearMonth的实例。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的年份
    
    month - 代表的月份，不为null
    
    结果
    
    年月，不为零
    
    异常
    
    DateTimeException - 如果年值无效
  - of
```
public static YearMonth of(int year,
                           int month)
```
    从一年和一个月获得 YearMonth的实例。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的年份
    
    month - 从1月1日至12日（12月）的月份，
    
    结果
    
    年月，不为零
    
    异常
    
    DateTimeException - 如果任一字段值无效
  - from
```
public static YearMonth from(TemporalAccessor temporal)
```
    从时间对象获取YearMonth的实例。
    这取决于指定时间的一个月。 A TemporalAccessor表示日期和时间信息的任意集合，该工厂将转换为YearMonth的实例。
    
    该转换提取了YEAR和MONTH_OF_YEAR字段。只有当时间对象具有ISO年表，或者可以转换为LocalDate ，才允许提取。
    
    该方法匹配功能接口TemporalQuery的签名，允许其通过方法参考YearMonth::from用作查询。
    
    参数
    
    temporal - 要转换的时间对象，不为null
    
    结果
    
    年月，不为零
    
    异常
    
    DateTimeException - 如果无法转换为 YearMonth
  - parse
```
public static YearMonth parse(CharSequence text)
```
    从文本字符串（例如2007-12获取YearMonth的实例。
    字符串必须表示有效的一个月。格式必须为uuuu-MM 。超出范围0000到9999之间的年份必须加上加号或减号。
    
    参数
    
    text - 要解析的文本，如“2007-12”，不为空
    
    结果
    
    解析的年月，不为零
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - parse
```
public static YearMonth parse(CharSequence text,
                              DateTimeFormatter formatter)
```
    使用特定的格式化程序从文本字符串获取YearMonth的实例。
    使用格式化程序解析文本，返回一个月。
    
    参数
    
    text - 要解析的文本，不为空
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    解析的年月，不为零
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定的字段是否受支持。
    这将检查是否可以查询指定字段的年月。如果是假，然后调用range ， get和with(TemporalField, long)方法会抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。支持的字段有：
    
    MONTH_OF_YEAR
    
    PROLEPTIC_MONTH
    
    YEAR_OF_ERA
    
    YEAR
    
    ERA
    
    所有其他ChronoField实例将返回false。
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.isSupportedBy(TemporalAccessor)传递this作为参数。字段是否受支持由字段决定。
    Specified by:
    
    isSupported在接口 TemporalAccessor
    
    参数
    
    field - 要检查的字段，null返回false
    
    结果
    
    如果该字段在今年支持，则为true，否则为false
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否受支持。
    这将检查指定的单位是否可以添加到今年或从今年减去。如果是false，那么调用plus(long, TemporalUnit)和minus方法会抛出异常。
    
    如果单位是ChronoUnit，那么查询是在这里实现的。支持的单位是：
    
    MONTHS
    
    YEARS
    
    DECADES
    
    CENTURIES
    
    MILLENNIA
    
    ERAS
    
    所有其他ChronoUnit实例将返回false。
    如果该单元不是ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.isSupportedBy(Temporal)传递this作为参数。设备是否受支持由本机决定。
    Specified by:
    
    isSupported在接口 Temporal
    
    参数
    
    unit - 要检查的单位，null返回false
    
    结果
    
    如果可以添加/减去单位，则为真，否则为false
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    范围对象表示字段的最小和最大有效值。今年用于提高返回范围的准确性。如果不可能返回范围，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。 supported fields将返回适当的范围实例。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.rangeRefinedBy(TemporalAccessor)传递this作为参数。是否可以获得范围由字段确定。
    
    Specified by:
    
    range在接口 TemporalAccessor
    
    参数
    
    field - 查询范围的字段，不为null
    
    结果
    
    字段的有效值的范围不为null
    
    异常
    
    DateTimeException - 如果无法获取字段的范围
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
  - get
```
public int get(TemporalField field)
```
    从本年度获取指定字段的值作为int 。
    这个年月查询指定字段的值。返回的值将始终在该字段的值的有效范围内。如果不可能返回值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。 supported fields将返回基于今年的有效值，除了PROLEPTIC_MONTH ，这太大，无法适应int并抛出DateTimeException 。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.getFrom(TemporalAccessor)传递this作为参数。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    get在接口 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值的范围
    
    UnsupportedTemporalTypeException - 如果该字段不受支持或值的范围超过 int
    
    ArithmeticException - 如果发生数字溢出
  - getLong
```
public long getLong(TemporalField field)
```
    从这个年月获得指定字段的值作为long 。
    这个年月查询指定字段的值。如果不可能返回值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。 supported fields将返回基于今年的有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.getFrom(TemporalAccessor)传递this作为参数。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    getLong在接口 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取字段的值
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - getYear
```
public int getYear()
```
    获取年份字段。
    此方法返回一年的原始值int 。
    
    通过这种方法返回的年份是根据get(YEAR)是灵巧的。
    
    结果
    
    年，从MIN_YEAR到MAX_YEAR
  - getMonthValue
```
public int getMonthValue()
```
    将月份字段从1到12。
    此方法将一个月作为int从1到12返回。如果通过调用getMonth()使用枚举Month，应用程序代码通常更清晰。
    
    结果
    
    从1到12年的月份
    
    另请参见：
    
    getMonth()
  - getMonth
```
public Month getMonth()
```
    使用Month枚举获取月份字段。
    此方法返回本月的枚举Month 。这避免了int值意味着什么的混乱。如果您需要访问原始的int值，则枚举将提供int value 。
    
    结果
    
    月份，不为零
    
    另请参见：
    
    getMonthValue()
  - isLeapYear
```
public boolean isLeapYear()
```
    根据ISO培训日历系统规则，检查年份是否是闰年。
    这种方法在整个时间线上应用目前的闰年规则。一般来说，一年是一个闰年，如果没有余数可以被四分割。但是，除了100岁之外，年份可以被分割为100岁，除了年龄可以被400除外。
    
    例如，1904年是一个闰年，可以被4整除。1900年不是一个闰年，因为它可以被100整除，然而2000年是一个闰年，因为它可以被400除数。
    
    计算是应激的 - 将相同的规则应用到远未来很远的地方。这在历史上是不准确的，但对于ISO-8601标准是正确的。
    
    结果
    
    如果一年是飞跃，否则为假
  - isValidDay
```
public boolean isValidDay(int dayOfMonth)
```
    检查月日是否在今年有效。
    此方法检查年，月和输入日形成有效日期。
    
    参数
    
    dayOfMonth - 验证的月份，从1到31，无效值返回false
    
    结果
    
    如果当天在今年有效，则为真
  - lengthOfMonth
```
public int lengthOfMonth()
```
    返回月份的长度，考虑到年份。
    这将以天为单位返回月份的长度。例如，1月份的日期将返回31。
    
    结果
    
    月份的天数，从28天到31天
  - lengthOfYear
```
public int lengthOfYear()
```
    返回一年的长度。
    这将返回年份的长度，以天数为365或366。
    
    结果
    
    366如果一年是飞跃，否则为365
  - with
```
public YearMonth with(TemporalAdjuster adjuster)
```
    返回今年的调整副本。
    这将返回一个YearMonth ，基于此，与年月调整。调整使用指定的调整器策略对象进行。阅读调整器的文档，了解将进行什么调整。
    
    一个简单的调整器可能只是设置一个字段，如年份字段。一个更复杂的调整者可能会将下个月的月份设定为Halley的彗星将通过地球。
    
    该方法的结果是通过调用TemporalAdjuster.adjustInto(Temporal)方法在指定的调整器通过this作为参数获得的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    adjuster - 调整器使用，不为空
    
    结果
    
    一个 YearMonth基于 this进行了调整，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public YearMonth with(TemporalField field,
                      long newValue)
```
    返回此年月份的副本，并将指定的字段设置为新值。
    这将返回一个YearMonth ，基于此，更改指定字段的值。这可以用于更改任何支持的字段，例如年份或月份。如果不可能设置该值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是ChronoField，则在此处执行调整。支持的字段的行为如下：
    
    MONTH_OF_YEAR - 返回指定月份的YearMonth 。年将不变。
    
    PROLEPTIC_MONTH - 返回一个YearMonth具有指定的月份。这完全取代了这个对象的年和月。
    
    YEAR_OF_ERA - 返回指定年龄的YearMonth月份和时代将不变。
    
    YEAR - 返回指定年份的YearMonth 。这个月不变。
    
    ERA - 返回指定时代的YearMonth 。月份和年龄将不变。
    
    在所有情况下，如果新值超出该字段值的有效范围，那么将抛出DateTimeException 。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    field - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 YearMonth基于 this指定字段集，不为null
    
    异常
    
    DateTimeException - 如果字段无法设置
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - withYear
```
public YearMonth withYear(int year)
```
    返回这个YearMonth的副本，并更改年份。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的返回年份设置的年份
    
    结果
    
    一个 YearMonth基于今年所要求的一年，不为零
    
    异常
    
    DateTimeException - 如果年值无效
  - withMonth
```
public YearMonth withMonth(int month)
```
    返回这个YearMonth的副本，其中YearMonth了月份。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month - 从1月（1月）至12月（12月），在返回的年份中设定的月份
    
    结果
    
    一个 YearMonth基于今年月份与请求的月份，不为null
    
    异常
    
    DateTimeException - 如果月份值无效
  - plus
```
public YearMonth plus(TemporalAmount amountToAdd)
```
    返回此年份的副本，并添加指定的金额。
    这将返回一个YearMonth ，基于此，添加了指定的数量。金额通常为Period，但可能是实现TemporalAmount接口的任何其他类型。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现添加，但是它通常会回调到plus(long, TemporalUnit) 。请参阅金额执行的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，不为null
    
    结果
    
    一个 YearMonth基于今年的增加，不是null
    
    异常
    
    DateTimeException - 如果不能添加
    
    ArithmeticException - 如果发生数字溢出
  - plus
```
public YearMonth plus(long amountToAdd,
                      TemporalUnit unit)
```
    返回此年份的副本，并添加指定的金额。
    这将返回一个YearMonth ，基于这一个，以添加的单位数量。如果不可能添加金额，因为单位不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoUnit，那么添加在这里实现。支持的字段的行为如下：
    
    MONTHS - 返回一个YearMonth ，加上指定的月数。这相当于plusMonths(long) 。
    
    YEARS - 返回指定年数的YearMonth 。这相当于plusYears(long) 。
    
    DECADES - 返回一个YearMonth ，加上指定的几十年。这相当于调用plusYears(long) ，数量乘以10。
    
    CENTURIES - 返回一个YearMonth具有指定的几个世纪。这相当于调用plusYears(long) ，数量乘以100。
    
    MILLENNIA - 返回一个YearMonth ，加上指定的几千年。这相当于调用plusYears(long) ，数量乘以1,000。
    
    ERAS - 返回一个YearMonth ，其中添加了指定的时间。只支持两个时间，所以数量必须是1，零或者减1。如果金额不是零，那么这个年份就会改变，使得年龄不变。
    
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.addTo(Temporal, long)传递this作为参数。在这种情况下，单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 要添加到结果中的单位数量，可能为负数
    
    unit - 要添加的单位，不为null
    
    结果
    
    一个 YearMonth基于这个年月加上指定的金额，不为null
    
    异常
    
    DateTimeException - 如果不能添加
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - plusYears
```
public YearMonth plusYears(long yearsToAdd)
```
    返回此YearMonth的副本，并附加指定的年数。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    yearsToAdd - 多年来补充，可能是负数
    
    结果
    
    一个 YearMonth基于今年增加的年份，不为零
    
    异常
    
    DateTimeException - 如果结果超出了支持的范围
  - plusMonths
```
public YearMonth plusMonths(long monthsToAdd)
```
    返回此YearMonth的副本，并附加指定的月数。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    monthsToAdd - 要添加的月份，可能为负数
    
    结果
    
    一个 YearMonth基于今年月份增加的月份，不为空
    
    异常
    
    DateTimeException - 如果结果超出了支持的范围
  - minus
```
public YearMonth minus(TemporalAmount amountToSubtract)
```
    返回减去指定数量的今年的副本。
    这将返回一个YearMonth ，基于此，减去指定的数量。金额通常为Period，但可能是实现TemporalAmount接口的任何其他类型。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现减法，但是它通常会调用到minus(long, TemporalUnit) 。请参阅数量执行的文档，以确定是否可以成功减去它们。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在接口 Temporal
    
    参数
    
    amountToSubtract - 减去量，不为空
    
    结果
    
    一个 YearMonth基于今年的减法而不是null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public YearMonth minus(long amountToSubtract,
                       TemporalUnit unit)
```
    返回减去指定数量的今年的副本。
    这将返回一个YearMonth ，基于此，减去单位的数量。如果不可能减去金额，因为该单位不受支持或出于某种其他原因，则会抛出异常。
    
    该方法相当于plus(long, TemporalUnit) ，其数量被否定。请参阅该方法，以了解如何添加，从而减去运算。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在接口 Temporal
    
    参数
    
    amountToSubtract - 从结果中减去的单位数量可能为负数
    
    unit - 减去量的单位，不为空
    
    结果
    
    一个 YearMonth基于今年减去指定数量，不为null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - minusYears
```
public YearMonth minusYears(long yearsToSubtract)
```
    返回此YearMonth的副本，并减去指定的年数。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    yearsToSubtract - 减去年份，可能为负数
    
    结果
    
    一个 YearMonth基于今年减去年，不为零
    
    异常
    
    DateTimeException - 如果结果超出了支持的范围
  - minusMonths
```
public YearMonth minusMonths(long monthsToSubtract)
```
    返回此YearMonth的副本，并减去指定的月数。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    monthsToSubtract - 减去数月，可能为负数
    
    结果
    
    一个 YearMonth基于今年减少的月份，不为零
    
    异常
    
    DateTimeException - 如果结果超出了支持范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询今年。
    这使用指定的查询策略对象查询今年。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档，以了解该方法的结果。
    
    该方法的结果是通过在指定的查询this作为参数调用TemporalQuery.queryFrom(TemporalAccessor)方法获得的。
    
    Specified by:
    
    query在接口 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，不为空
    
    结果
    
    查询结果可能返回null（由查询定义）
    
    异常
    
    DateTimeException - 如果无法查询（由查询定义）
    
    ArithmeticException - 如果发生数字溢出（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    将指定的时间对象调整为今年。
    这返回与年和月份的输入相同的可观察类型的时间对象与此相同。
    
    该调整是相当于使用Temporal.with(TemporalField, long)通过ChronoField.PROLEPTIC_MONTH作为字段。如果指定的时间对象不使用ISO日历系统，则抛出DateTimeException 。
    
    在大多数情况下，通过使用Temporal.with(TemporalAdjuster)来更正呼叫模式：
    
    // these two lines are equivalent, but the second approach is recommended temporal = thisYearMonth.adjustInto(temporal); temporal = temporal.with(thisYearMonth);
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto在接口 TemporalAdjuster
    
    参数
    
    temporal - 要调整的目标对象，不为null
    
    结果
    
    调整对象，不为null
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定单位计算直到另一个一个月的时间量。
    这可以计算一个YearMonth对象之间的时间量，单个TemporalUnit 。起点和终点是this和指定的年月。如果结束在开始之前，结果将为负数。所述Temporal传递给此方法被转换为YearMonth使用from(TemporalAccessor) 。例如，可以使用startYearMonth.until(endYearMonth, YEARS)计算两年之间的年数。
    
    计算返回一个整数，表示两个月之间的完整单位数。例如，2012-06年至2032-05年间的数十年将只有二十年的一个月。
    
    使用这种方法有两种等效的方法。第一个是调用这个方法。二是使用TemporalUnit.between(Temporal, Temporal) ：
    
    // these two lines are equivalent amount = start.until(end, MONTHS); amount = MONTHS.between(start, end);
    应该根据这种做法进行选择，使代码更易读。
    以此方法计算ChronoUnit 。单位MONTHS ， YEARS ， DECADES ， CENTURIES ， MILLENNIA和ERAS的支持。其他ChronoUnit值会抛出异常。
    
    如果该单元不是ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.between(Temporal, Temporal)传递this作为第一个参数和转换后的输入时间作为第二个参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until在接口 Temporal
    
    参数
    
    endExclusive - 结束日期，排他，转换为 YearMonth ，不为空
    
    unit - 衡量金额的单位，不为空
    
    结果
    
    今年至今年底的时间
    
    异常
    
    DateTimeException - 如果不能计算金额，或者结束时间不能转换为 YearMonth
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - format
```
public String format(DateTimeFormatter formatter)
```
    使用指定的格式化程序在今年的格式。
    今年将被传递给格式化程序来生成一个字符串。
    
    参数
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    格式化的年份字符串，不为空
    
    异常
    
    DateTimeException - 打印过程中是否发生错误
  - atDay
```
public LocalDate atDay(int dayOfMonth)
```
    结合今年的月份，创造一个LocalDate 。
    这将返回一个LocalDate ，从今年月份和指定的日期形成。
    
    月日的价值必须在年月有效。
    
    该方法可以用作链的一部分来生成日期：
    
    LocalDate date = year.atMonth(month).atDay(day);
    参数
    
    dayOfMonth - 使用月份，从1到31
    
    结果
    
    从今年和特定日期形成的日期不为零
    
    异常
    
    DateTimeException - 如果一天的年份无效
    
    另请参见：
    
    isValidDay(int)
  - atEndOfMonth
```
public LocalDate atEndOfMonth()
```
    在本月底返回LocalDate 。
    这将返回一个基于今年的LocalDate 。每月的最后一个有效日期，考虑到闰年。
    
    该方法可以用作链的一部分来生成日期：
    
    LocalDate date = year.atMonth(month).atEndOfMonth();
    结果
    
    今年的最后有效日期，不为空
  - compareTo
```
public int compareTo(YearMonth other)
```
    比较今年至另一个月。
    这个比较首先是基于年的价值，然后是月的价值。它与“等于”一致，如Comparable所定义。
    
    Specified by:
    
    compareTo在接口 Comparable<YearMonth>
    
    参数
    
    other - 与其他年份进行比较，不为空
    
    结果
    
    比较器值为负，如果较小，则如果较大则为正
  - isAfter
```
public boolean isAfter(YearMonth other)
```
    检查这个年月是否在指定的年月之后。
    
    参数
    
    other - 其他年月比较，不为null
    
    结果
    
    如果这是指定的年月之后，则为真
  - isBefore
```
public boolean isBefore(YearMonth other)
```
    检查这个年月是否在指定的年份之前。
    
    参数
    
    other - 其他年月比较，不为null
    
    结果
    
    如果这一点在指定的年月之前，则为真
  - equals
```
public boolean equals(Object obj)
```
    检查这个年月是否等于另一个一个月。
    比较是基于年月日的时间位置。
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - 要检查的对象，null返回false
    
    结果
    
    如果这等于其他年份，则为true
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    今年的哈希码。
    
    重写：
    
    hashCode在 Object
    
    结果
    
    一个合适的哈希码
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    今年产量为String ，如2007-12 。
    输出格式为uuuu-MM ：
    
    重写：
    
    toString在 Object
    
    结果
    
    今年的字符串表示，不为空

Class YearMonth

方法摘要

Methods inherited from class java.lang.Object

方法详细信息

now

now

now

of

of

from

parse

parse

isSupported

isSupported

range

get

getLong

getYear

getMonthValue

getMonth

isLeapYear

isValidDay

lengthOfMonth

lengthOfYear

with

with

withYear

withMonth

plus

plus

plusYears

plusMonths

minus

minus

minusYears

minusMonths

query

adjustInto

until

format

atDay

atEndOfMonth

compareTo

isAfter

isBefore

equals

hashCode

toString