实现的所有接口

Serializable ， Comparable<YearMonth> ， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class YearMonthextends Objectimplements 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

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`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`	`withYear(int year)`	返回此 `YearMonth`的副本，并更改年份。

声明方法的类 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，不为null
    
    结果
    
    使用系统时钟的当前年月，不为空
  - 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 - 表示的月份而非空值
    
    结果
    
    年 - 月，不是空的
    
    异常
    
    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的实例。
    这将根据指定的时间获得年月。 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”，而不是null
    
    结果
    
    解析的年月，不是空的
    
    异常
    
    DateTimeParseException - 如果无法解析文本
  - parse
```
public static YearMonth parse(CharSequence text,                              DateTimeFormatter formatter)
```
    使用特定格式化程序从文本字符串中获取YearMonth的实例。
    使用格式化程序解析文本，返回一年。
    
    参数
    
    text - 要解析的文本，而不是null
    
    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 ，则通过调用this作为参数调用TemporalField.isSupportedBy(TemporalAccessor)来获得此方法的结果。字段是否受支持由字段确定。
    Specified by:
    
    isSupported在界面 TemporalAccessor
    
    参数
    
    字段 - 要检查的字段，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 in interface Temporal
    
    参数
    
    unit - 要检查的单位，null返回false
    
    结果
    
    如果可以添加/减去单位，则为true，否则为false
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值范围。
    范围对象表示字段的最小和最大有效值。今年 - 月用于提高返回范围的准确性。如果无法返回范围，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处执行查询。 supported fields将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.rangeRefinedBy(TemporalAccessor)传递this作为参数。是否可以获得范围由该字段确定。
    
    Specified by:
    
    range在界面 TemporalAccessor
    
    参数
    
    字段 - 要查询范围的字段，而不是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
    
    参数
    
    字段 - 要获取的字段，而不是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
    
    参数
    
    字段 - 要获取的字段，而不是null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取该字段的值
    
    UnsupportedTemporalTypeException - 如果不支持该字段
    
    ArithmeticException - 如果发生数字溢出
  - getYear
```
public int getYear()
```
    获取年份字段。
    此方法返回年份的原始值int 。
    
    根据get(YEAR) ，此方法返回的年份是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符号日历系统规则，检查年份是否为闰年。
    此方法在整个时间线上应用闰年的当前规则。一般来说，一年是闰年，如果它可以被4整除而没有余数。然而，可以被100整除的年份不是闰年，除了可以被400整除的年份。
    
    例如，1904年是闰年，它可以被4整除.1900不是闰年，因为它可以被100整除，但2000年是闰年，因为它可以被400整除。
    
    计算是渐近的 - 将相同的规则应用到遥远的未来和远期。这在历史上是不准确的，但对于ISO-8601标准是正确的。
    
    结果
    
    如果年份是飞跃则为true，否则为false
  - 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 ，基于此，调整年度。使用指定的调整器策略对象进行调整。阅读调整器的文档，了解将进行哪些调整。
    
    简单的调整器可能只是设置其中一个字段，例如年份字段。一个更复杂的调节器可能会将下一个月的月份设置为哈雷彗星将通过地球的下个月。
    
    通过在指定的调整器上调用TemporalAdjuster.adjustInto(Temporal)方法（通过this作为参数）来获得此方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在界面 Temporal
    
    参数
    
    adjuster - 要使用的调整器，不为null
    
    结果
    
    a YearMonth基于 this进行调整，不为空
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public YearMonth with(TemporalField field,                      long newValue)
```
    返回此年月的副本，并将指定的字段设置为新值。
    这将返回一个YearMonth ，基于此值，更改指定字段的值。这可用于更改任何支持的字段，例如年份或月份。如果无法设置该值，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处执行调整。支持的字段表现如下：
    
    MONTH_OF_YEAR - 返回具有指定月份的YearMonth 。这一年将保持不变。
    
    PROLEPTIC_MONTH - 返回具有指定的proleptic-month的YearMonth 。这完全取代了此对象的年份和月份。
    
    YEAR_OF_ERA - 返回具有指定年份的YearMonth月份和时代将保持不变。
    
    YEAR - 返回指定年份的YearMonth 。这个月将保持不变。
    
    ERA - 返回具有指定时代的YearMonth 。月份和年份将保持不变。
    
    在所有情况下，如果新值超出该字段的有效值范围，则将抛出DateTimeException 。
    
    所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段确定是否以及如何调整瞬间。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with接口 Temporal
    
    参数
    
    字段 - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    a YearMonth基于 this ，指定字段集，不为空
    
    异常
    
    DateTimeException - 如果无法设置该字段
    
    UnsupportedTemporalTypeException - 如果不支持该字段
    
    ArithmeticException - 如果发生数字溢出
  - withYear
```
public YearMonth withYear(int year)
```
    返回此YearMonth的副本，并更改年份。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year - 返回的年 - 月中设置的年份，从MIN_YEAR到MAX_YEAR
    
    结果
    
    a YearMonth基于今年和所请求年份的月份，不为空
    
    异常
    
    DateTimeException - 如果年份值无效
  - withMonth
```
public YearMonth withMonth(int month)
```
    返回此YearMonth的副本，其中年份已更改。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month - 在返回的年度月中设置的月份，从1（1月）到12（12月）
    
    结果
    
    a YearMonth基于此年份的请求月份，不为空
    
    异常
    
    DateTimeException - 如果月份值无效
  - plus
```
public YearMonth plus(TemporalAmount amountToAdd)
```
    返回指定金额的今年的副本。
    这将返回基于此值的YearMonth ，并添加指定的数量。金额通常为Period，但可能是实现TemporalAmount界面的任何其他类型。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给amount对象。实施金额可以任意方式自由实施，但通常会回拨plus(long, TemporalUnit) 。请参阅金额实施的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，不为空
    
    结果
    
    a YearMonth基于此年份而添加，不为空
    
    异常
    
    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 ，其中添加了指定的YearMonth数。仅支持两个时代，因此金额必须为一，零或负一。如果金额不为零，则改变年份，使得年龄不变。
    
    所有其他ChronoUnit实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoUnit ，则此方法的结果是通过调用获得TemporalUnit.addTo(Temporal, long)传递this作为参数。在这种情况下，该单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus in interface Temporal
    
    参数
    
    amountToAdd - 要添加到结果中的单位数量可能为负数
    
    unit - 要添加的金额的单位，而不是空
    
    结果
    
    基于此年份的 YearMonth ，添加了指定的金额，而不是空
    
    异常
    
    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)将计算委托给amount对象。实现量可以任意方式自由实现减法，但通常会回调到minus(long, TemporalUnit) 。请参阅金额实施的文档，以确定是否可以成功减去它。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在界面 Temporal
    
    参数
    
    amountToSubtract - 要减去的金额，而不是空
    
    结果
    
    基于此 YearMonth进行减法，而不是空
    
    异常
    
    DateTimeException - 如果无法进行减法
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public YearMonth minus(long amountToSubtract,                       TemporalUnit unit)
```
    返回此年月份的副本，并减去指定的金额。
    这将返回一个YearMonth ，基于此值，减去单位的数量。如果无法减去金额，因为不支持该单位或由于某些其他原因，则抛出异常。
    
    该方法相当于plus(long, TemporalUnit) ，其数量为负数。有关添加和减法如何工作的完整描述，请参阅该方法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在界面 Temporal
    
    参数
    
    amountToSubtract - 从结果中减去的单位数量可能为负数
    
    unit - 要减去的金额的单位，而不是空
    
    结果
    
    基于此 YearMonth ，减去指定的金额，不为空
    
    异常
    
    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对象定义用于获取结果的逻辑。阅读查询文档以了解此方法的结果。
    
    通过在指定的查询上调用TemporalQuery.queryFrom(TemporalAccessor)方法作为参数传递this来获得此方法的结果。
    
    Specified by:
    
    query在界面 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，而不是null
    
    结果
    
    查询结果，可以返回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
    
    结果
    
    调整后的对象，不为空
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,                  TemporalUnit unit)
```
    根据指定的单位计算直到另一年 - 月的时间量。
    这将根据单个TemporalUnit计算两个YearMonth对象之间的时间量。起点和终点是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 - 要比较的另一年 - 月，而不是空
    
    结果
    
    如果这是在指定的年月之后，则为true
  - isBefore
```
public boolean isBefore(YearMonth other)
```
    检查此年月是否在指定的年月之前。
    
    参数
    
    other - 与之比较的另一年 - 月，而不是null
    
    结果
    
    如果此点在指定的年月之前，则为true
  - equals
```
public boolean equals(Object obj)
```
    检查此年月是否等于另一年 - 月。
    比较基于年 - 月的时间线位置。
    
    重写：
    
    equals in class Object
    
    参数
    
    obj - 要检查的对象，null返回false
    
    结果
    
    如果这等于其他年月，则为true
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    今年的哈希码。
    
    重写：
    
    hashCode in class Object
    
    结果
    
    合适的哈希码
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    今年的产出为String ，如2007-12 。
    输出格式为uuuu-MM ：
    
    重写：
    
    toString在课程 Object
    
    结果
    
    此年月的字符串表示形式，不为空

Class YearMonth

方法摘要

声明方法的类 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