OffsetTime (Java Platform SE 8 )

java.lang.Object
- java.time.OffsetTime

All Implemented Interfaces:

Serializable ， Comparable < OffsetTime >， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class OffsetTime
extends Object
implements Temporal, TemporalAdjuster, Comparable<OffsetTime>, Serializable
```
在ISO-8601日历系统中偏离UTC /格林威治的时间，如10:15:30+01:00 。
OffsetTime是一个不可变的日期时间对象，表示一个时间，通常被视为小时 - 秒 - 秒。该类存储所有时间字段，精度为纳秒，以及区域偏移量。例如，值“13：45.30.123456789 + 02：00”可以存储在OffsetTime 。

这是一个value-based类; 使用身份敏感的操作（包括引用相等（的==上的实例），标识哈希码，或同步） OffsetTime可具有不可预测的结果，应当避免。 equals方法应用于比较。

实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static OffsetTime`	`MAX` 最大支持 `OffsetTime` ， `OffsetTime` ：59：59.999999999-18：00'。
`static OffsetTime`	`MIN` 最低支持 `OffsetTime` ：00：00 + 18：00'。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象与此对象具有相同的偏移量和时间。
`OffsetDateTime`	`atDate(LocalDate date)` 结合这个时间与一个日期创建一个 `OffsetDateTime` 。
`int`	`compareTo(OffsetTime other)` 比较这个 `OffsetTime`到另一个时间。
`boolean`	`equals(Object obj)` 检查这次是否等于另一次。
`String`	`format(DateTimeFormatter formatter)` 此时使用指定的格式化程序格式化。
`static OffsetTime`	`from(TemporalAccessor temporal)` 从时间对象获取一个 `OffsetTime`的实例。
`int`	`get(TemporalField field)` 从此时间获取指定字段的 `int` 。
`int`	`getHour()` 获取时间字段。
`long`	`getLong(TemporalField field)` 从此时间获取指定字段的值为 `long` 。
`int`	`getMinute()` 获取小时字段。
`int`	`getNano()` 获得纳秒第二场。
`ZoneOffset`	`getOffset()` 获取区域偏移量，例如“+01：00”。
`int`	`getSecond()` 获得第二分钟的字段。
`int`	`hashCode()` 这个时候的哈希码。
`boolean`	`isAfter(OffsetTime other)` 检查此 `OffsetTime`是否在指定的时间之后，将两次都应用到公用日期。
`boolean`	`isBefore(OffsetTime other)` 检查此 `OffsetTime`是否在指定的时间之前，将两次都应用到公共日期。
`boolean`	`isEqual(OffsetTime other)` 检查此 `OffsetTime`的时间是否与将两次应用于公共日期的指定时间相同。
`boolean`	`isSupported(TemporalField field)` 检查指定的字段是否受支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否受支持。
`OffsetTime`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此次的副本，减去指定的金额。
`OffsetTime`	`minus(TemporalAmount amountToSubtract)` 返回此次的副本，减去指定的金额。
`OffsetTime`	`minusHours(long hours)` 以指定的周期返回此 `OffsetTime`的副本， `OffsetTime`数小时。
`OffsetTime`	`minusMinutes(long minutes)` 返回此 `OffsetTime`的副本，其中指定的时间间隔以分钟为单位。
`OffsetTime`	`minusNanos(long nanos)` 返回此副本 `OffsetTime`在扣除纳秒指定的期限。
`OffsetTime`	`minusSeconds(long seconds)` 返回此 `OffsetTime`的副本，其中指定的时间间隔以秒为单位。
`static OffsetTime`	`now()` 从默认时区的系统时钟获取当前时间。
`static OffsetTime`	`now(Clock clock)` 从指定的时钟获取当前时间。
`static OffsetTime`	`now(ZoneId zone)` 从指定时区的系统时钟获取当前时间。
`static OffsetTime`	`of(int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset)` 从一小时，分钟，秒和纳秒获取一个 `OffsetTime`的实例。
`static OffsetTime`	`of(LocalTime time, ZoneOffset offset)` 从当地时间和偏移量获取一个 `OffsetTime`的实例。
`static OffsetTime`	`ofInstant(Instant instant, ZoneId zone)` 从 `Instant`和区域ID获取一个 `OffsetTime`的实例。
`static OffsetTime`	`parse(CharSequence text)` 从文本字符串（例如 `10:15:30+01:00`获取一个 `OffsetTime`的实例。
`static OffsetTime`	`parse(CharSequence text, DateTimeFormatter formatter)` 使用特定的格式化 `OffsetTime`从文本字符串获取一个 `OffsetTime`的实例。
`OffsetTime`	`plus(long amountToAdd, TemporalUnit unit)` 返回此时添加了指定数量的副本。
`OffsetTime`	`plus(TemporalAmount amountToAdd)` 返回此时添加了指定数量的副本。
`OffsetTime`	`plusHours(long hours)` 以指定的时间（以小时为单位）返回此 `OffsetTime`的副本。
`OffsetTime`	`plusMinutes(long minutes)` 以指定的时间（以分钟为单位）返回此 `OffsetTime`的副本。
`OffsetTime`	`plusNanos(long nanos)` 以指定的时间段返回此 `OffsetTime`的副本，以纳秒为单位。
`OffsetTime`	`plusSeconds(long seconds)` 以指定的时间段（以秒为单位）返回此 `OffsetTime`的副本。
`<R> R`	`query(TemporalQuery<R> query)` 此时使用指定的查询进行查询。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`LocalTime`	`toLocalTime()` 获取此日期时间的部分 `LocalTime` 。
`String`	`toString()` 此时输出为 `String` ，如 `10:15:30+01:00` 。
`OffsetTime`	`truncatedTo(TemporalUnit unit)` 返回此 `OffsetTime`的副本， `OffsetTime`时间。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 根据指定的单位计算直到另一次的时间量。
`OffsetTime`	`with(TemporalAdjuster adjuster)` 返回此次调整后的副本。
`OffsetTime`	`with(TemporalField field, long newValue)` 返回此时间的副本，并将指定的字段设置为新值。
`OffsetTime`	`withHour(int hour)` 返回此 `OffsetTime`的副本，并更改日期值。
`OffsetTime`	`withMinute(int minute)` 返回这个 `OffsetTime`的副本，小时值更改。
`OffsetTime`	`withNano(int nanoOfSecond)` 返回这个 `OffsetTime`的副本，纳秒变化值。
`OffsetTime`	`withOffsetSameInstant(ZoneOffset offset)` 返回此副本 `OffsetTime`具有指定偏移确保结果是在对隐含一天同一时刻。
`OffsetTime`	`withOffsetSameLocal(ZoneOffset offset)` 以指定的偏移量返回此 `OffsetTime`的副本，确保结果具有相同的本地时间。
`OffsetTime`	`withSecond(int second)` 返回这个 `OffsetTime`的副本，并更改秒数值。

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

- 字段详细信息
  - MIN
```
public static final OffsetTime MIN
```
    最低支持OffsetTime ：00：00 + 18：00'。这是在最大偏移量的一天开始的午夜时间（更大的偏移在时间线上较早）。这结合了LocalTime.MIN和ZoneOffset.MAX 。应用程序可以将其用作“过去”的日期。
  - MAX
```
public static final OffsetTime MAX
```
    最大支持OffsetTime ， OffsetTime ：59：59.999999999-18：00'。这是在最后偏移量的最后一天午夜之前的时间（较大的负偏移量稍后在时间线上）。这结合了LocalTime.MAX和ZoneOffset.MIN 。应用程序可以将其用作“远未来”的日期。
- 方法详细信息
  - now
```
public static OffsetTime now()
```
    从默认时区的系统时钟获取当前时间。
    这将查询默认时区中的system clock以获取当前时间。偏移量将从时钟的时区计算。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    结果
    
    当前时间使用系统时钟，不为空
  - now
```
public static OffsetTime now(ZoneId zone)
```
    从指定时区的系统时钟获取当前时间。
    这将查询system clock获取当前时间。指定时区可以避免对默认时区的依赖。偏移量将从指定的时区计算。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    参数
    
    zone - 要使用的区域ID，不为空
    
    结果
    
    当前时间使用系统时钟，不为空
  - now
```
public static OffsetTime now(Clock clock)
```
    从指定的时钟获取当前时间。
    这将查询指定的时钟以获取当前时间。偏移量将从时钟的时区计算。
    
    使用此方法可以使用备用时钟进行测试。替代时钟可以使用dependency injection引入。
    
    参数
    
    clock - 要使用的时钟，不为空
    
    结果
    
    当前时间，不为null
  - of
```
public static OffsetTime of(LocalTime time,
                            ZoneOffset offset)
```
    从本地时间和偏移量获取一个 OffsetTime的实例。
    
    参数
    
    time - 当地时间，不为空
    
    offset - 区域偏移，不为空
    
    结果
    
    偏移时间，不为空
  - of
```
public static OffsetTime of(int hour,
                            int minute,
                            int second,
                            int nanoOfSecond,
                            ZoneOffset offset)
```
    从一小时，分钟，秒和纳秒获取一个OffsetTime的实例。
    这将为四个指定的字段创建一个偏移时间。
    
    该方法主要用于编写测试用例。非测试代码通常会使用其他方法来创建一个偏移时间。 LocalTime具有两个额外的方便的变体，相当于工厂方法的参数较少。在这里不提供它们来减少API的占用空间。
    
    参数
    
    hour - 代表从0到23的小时
    
    minute - 表示从0到59的小时
    
    second - 从0到59的秒表示
    
    nanoOfSecond - 代表从0到999,999,999的纳秒
    
    offset - 区域偏移，不为空
    
    结果
    
    偏移时间，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - ofInstant
```
public static OffsetTime ofInstant(Instant instant,
                                   ZoneId zone)
```
    从Instant和区域ID获取一个OffsetTime的实例。
    这将产生与指定的相同时间的偏移时间。找到UTC /格林威治的偏移量很简单，因为每个瞬间只有一个有效的偏移量。
    
    在转换期间，该瞬间的日期组件被丢弃。这意味着转换永远不会因为瞬间超出有效的日期范围而失败。
    
    参数
    
    instant - 即时创建时间，不为null
    
    zone - 时区，可能是偏移，不为空
    
    结果
    
    偏移时间，不为空
  - from
```
public static OffsetTime from(TemporalAccessor temporal)
```
    从时间对象获取一个OffsetTime的实例。
    这获得了基于指定时间的偏移时间。 A TemporalAccessor表示一个任意的日期和时间信息集，该工厂转换为OffsetTime一个实例。
    
    转换提取并结合ZoneOffset和LocalTime从时间对象。允许实现执行优化，例如访问与相关对象相当的那些字段。
    
    该方法中，功能接口的签名相匹配TemporalQuery允许它在通过方法参考，查询中使用OffsetTime::from 。
    
    参数
    
    temporal - 要转换的时间对象，不为null
    
    结果
    
    偏移时间，不为空
    
    异常
    
    DateTimeException - 如果无法转换为 OffsetTime
  - parse
```
public static OffsetTime parse(CharSequence text)
```
    从文本字符串（例如10:15:30+01:00获取一个OffsetTime的实例。
    字符串必须表示有效的时间，并使用DateTimeFormatter.ISO_OFFSET_TIME进行解析。
    
    参数
    
    text - 要解析的文本，如“ text ”，不为空
    
    结果
    
    解析当地时间，不为空
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - parse
```
public static OffsetTime parse(CharSequence text,
                               DateTimeFormatter formatter)
```
    使用特定的格式化OffsetTime从文本字符串获取一个OffsetTime的实例。
    使用格式化程序解析文本，返回一个时间。
    
    参数
    
    text - 要解析的文本，不为空
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    解析的偏移时间，不为null
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定的字段是否受支持。
    这将检查此时间是否可以查询指定的字段。如果是假，然后调用range ， get和with(TemporalField, long)方法会抛出异常。
    
    如果该字段是ChronoField，那么查询是在这里实现的。支持的字段有：
    - NANO_OF_SECOND
    - NANO_OF_DAY
    - MICRO_OF_SECOND
    - MICRO_OF_DAY
    - MILLI_OF_SECOND
    - MILLI_OF_DAY
    - SECOND_OF_MINUTE
    - SECOND_OF_DAY
    - MINUTE_OF_HOUR
    - MINUTE_OF_DAY
    - HOUR_OF_AMPM
    - CLOCK_HOUR_OF_AMPM
    - HOUR_OF_DAY
    - CLOCK_HOUR_OF_DAY
    - AMPM_OF_DAY
    - OFFSET_SECONDS
    所有其他ChronoField实例将返回false。
    如果该字段不是ChronoField ，则通过调用TemporalField.isSupportedBy(TemporalAccessor) this作为参数的this获得该方法的结果。字段是否受支持由字段决定。
    Specified by:
    
    isSupported在接口 TemporalAccessor
    
    参数
    
    field - 要检查的字段，null返回false
    
    结果
    
    如果此时支持该字段，则为true，否则为false
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否受支持。
    这将检查指定的单位是否可以添加到该日期时间或从该日期时间中减去。如果是false，那么调用plus(long, TemporalUnit)和minus方法会抛出异常。
    
    如果单位是ChronoUnit，那么查询是在这里实现的。支持的单位是：
    - NANOS
    - MICROS
    - MILLIS
    - SECONDS
    - MINUTES
    - HOURS
    - HALF_DAYS
    所有其他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将返回除了基于这个时候有效值， NANO_OF_DAY和MICRO_OF_DAY这是太大，无法在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作为参数的this获取此方法的结果。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    getLong在接口 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取该字段的值
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - getOffset
```
public ZoneOffset getOffset()
```
    获取区域偏移量，例如“+01：00”。
    这是当地时间与UTC /格林威治的抵消。
    
    结果
    
    区域偏移，不为空
  - withOffsetSameLocal
```
public OffsetTime withOffsetSameLocal(ZoneOffset offset)
```
    返回此副本OffsetTime具有指定偏移确保结果具有相同的本地时间。
    此方法返回一个具有相同的对象LocalTime和指定的ZoneOffset 。不需要或执行计算。例如，如果此时间表示10:30+02:00 ，并且指定的偏移量为+03:00 ，则此方法将返回10:30+03:00 。
    
    要考虑到偏差之间的差异，并调整时间字段，请使用withOffsetSameInstant(java.time.ZoneOffset) 。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    offset - 要更改的区域偏移量，不为空
    
    结果
    
    一个 OffsetTime基于此时与请求的偏移量，不为null
  - withOffsetSameInstant
```
public OffsetTime withOffsetSameInstant(ZoneOffset offset)
```
    返回此副本OffsetTime具有指定偏移确保结果是在对隐含一天同一时刻。
    此方法返回一个具有指定的对象ZoneOffset和LocalTime由两个偏移之间的LocalTime进行调整。这将导致旧的和新的对象代表相同的瞬间是隐含的一天。这对于在不同的偏移量中找到本地时间是有用的。例如，如果此时间表示10:30+02:00 ，并且指定的偏移量为+03:00 ，则此方法将返回11:30+03:00 。
    
    要更改偏移量而不调整本地时间使用withOffsetSameLocal(java.time.ZoneOffset) 。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    offset - 要更改的区域偏移量，不为空
    
    结果
    
    一个 OffsetTime基于此时间与请求的偏移量，不为null
  - toLocalTime
```
public LocalTime toLocalTime()
```
    获得这个日期时间的LocalTime部分。
    这将返回一个LocalTime与这个日期时间相同的小时，分，秒和纳秒。
    
    结果
    
    这个日期时间的一部分，不是null
  - getHour
```
public int getHour()
```
    获取时间字段。
    
    结果
    
    时间从0到23
  - getMinute
```
public int getMinute()
```
    获取小时字段。
    
    结果
    
    分钟，从0到59
  - getSecond
```
public int getSecond()
```
    获得第二分钟的字段。
    
    结果
    
    第二分钟，从0到59
  - getNano
```
public int getNano()
```
    获得纳秒第二场。
    
    结果
    
    纳秒，从0到999,999,999
  - with
```
public OffsetTime with(TemporalAdjuster adjuster)
```
    返回此次调整后的副本。
    这返回一个OffsetTime ，基于这一个，随着时间的推移。调整使用指定的调整器策略对象进行。阅读调整器的文档，了解将进行什么调整。
    
    一个简单的调整器可以简单地设置一个字段，如小时字段。更复杂的调整器可能会将时间设置为一天中的最后一个小时。
    
    类别LocalTime和ZoneOffset实现TemporalAdjuster ，因此该方法可用于更改时间或偏移量：
```
  result = offsetTime.with(time);
  result = offsetTime.with(offset); 
```
    该方法的结果是通过调用指定调整器this作为参数的TemporalAdjuster.adjustInto(Temporal)方法获得的。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在界面 Temporal
    
    参数
    
    adjuster - 调整器使用，不为空
    
    结果
    
    一个 OffsetTime基于 this与制造，不为空调整
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public OffsetTime with(TemporalField field,
                       long newValue)
```
    返回此时间的副本，并将指定的字段设置为新值。
    这将返回一个OffsetTime ，基于此，更改指定字段的值。这可以用于更改任何支持的字段，如小时，分钟或秒。如果不可能设置该值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是ChronoField，则在此处执行调整。
    
    OFFSET_SECONDS字段将返回指定偏移量的时间。当地时间不变。如果新的偏移值超出有效范围，那么将抛出一个DateTimeException 。
    
    其他supported fields将按照LocalTime.with(TemporalField, long) LocalTime}上的匹配方法进行操作。在这种情况下，偏移不是计算的一部分，将不会改变。
    
    所有其他ChronoField实例都会抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在界面 Temporal
    
    参数
    
    field - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 OffsetTime基于 this与指定的字段集，不为null
    
    异常
    
    DateTimeException - 如果该字段无法设置
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - withHour
```
public OffsetTime withHour(int hour)
```
    返回此OffsetTime的副本，并更改日期值。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour - 设置结果的时间从0到23
    
    结果
    
    一个 OffsetTime基于此时间与请求的小时，不为null
    
    异常
    
    DateTimeException - 如果小时值无效
  - withMinute
```
public OffsetTime withMinute(int minute)
```
    返回这个OffsetTime的副本，小时值更改。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute - 在0到59之间设置结果的小时
    
    结果
    
    一个 OffsetTime基于此时间与请求的分钟，不为null
    
    异常
    
    DateTimeException - 如果分钟值无效
  - withSecond
```
public OffsetTime withSecond(int second)
```
    返回这个OffsetTime的副本，其中二分之一值更改。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second - 在0到59之间设置结果的 second
    
    结果
    
    一个 OffsetTime基于此时与请求的第二个，不为null
    
    异常
    
    DateTimeException - 如果第二个值无效
  - withNano
```
public OffsetTime withNano(int nanoOfSecond)
```
    返回这个OffsetTime的副本，纳秒变化值。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond - 纳秒秒在结果中设置，从0到999,999,999
    
    结果
    
    一个 OffsetTime基于这个时间与请求的纳秒，不为null
    
    异常
    
    DateTimeException - 如果 DateTimeException值无效
  - truncatedTo
```
public OffsetTime truncatedTo(TemporalUnit unit)
```
    返回此副本OffsetTime以截断的时间。
    截断返回原始时间的副本，其中小于指定单位的字段设置为零。例如，使用minutes单位进行截断将将第二分钟和第二纳秒字段设置为零。
    
    该单位必须有一个duration ，划分为标准日期的长度，无余数。这包括所有提供的时间单位在ChronoUnit和DAYS 。其他单位抛出异常。
    
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 截断到的单位，不为空
    
    结果
    
    一个 OffsetTime基于此时间截断，不为null
    
    异常
    
    DateTimeException - 如果无法截断
    
    UnsupportedTemporalTypeException - 如果不支持本机
  - plus
```
public OffsetTime plus(TemporalAmount amountToAdd)
```
    返回此时添加了指定数量的副本。
    这返回一个OffsetTime ，基于这一个，添加了指定的数量。量通常是Duration但也可以是任何其他类型的实现TemporalAmount接口。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现添加，但是它通常会回调到plus(long, TemporalUnit) 。请参阅金额执行的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，不为null
    
    结果
    
    一个 OffsetTime基于这个时间加上，而不是null
    
    异常
    
    DateTimeException - 如果不能添加
    
    ArithmeticException - 如果发生数字溢出
  - plus
```
public OffsetTime plus(long amountToAdd,
                       TemporalUnit unit)
```
    返回此时添加了指定数量的副本。
    这返回一个OffsetTime ，基于这一个，增加的单位的数额。如果不可能添加金额，因为单位不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是ChronoUnit，那么加法是由LocalTime.plus(long, TemporalUnit)实现的。偏移量不是计算的一部分，结果将不变。
    
    如果该字段是不是一个ChronoUnit ，则此方法的结果是通过调用获得TemporalUnit.addTo(Temporal, long)传递this作为参数。在这种情况下，单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 添加到结果中的单位数量可能为负数
    
    unit - 要添加的单位，不为空
    
    结果
    
    一个 OffsetTime基于这个时间与指定的数量添加，不为null
    
    异常
    
    DateTimeException - 如果不能添加
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - plusHours
```
public OffsetTime plusHours(long hours)
```
    以指定的周期返回此OffsetTime的副本，小时数。
    这样就增加了指定的小时数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours - 要添加的时间可能为负数
    
    结果
    
    一个 OffsetTime基于这个时间加上的时间，不是null
  - plusMinutes
```
public OffsetTime plusMinutes(long minutes)
```
    以指定的时间段（以分钟为单位）返回此OffsetTime的副本。
    这样就添加了指定的分钟数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes - 要添加的分钟可能为负数
    
    结果
    
    一个 OffsetTime基于这个时间加上分钟，不是null
  - plusSeconds
```
public OffsetTime plusSeconds(long seconds)
```
    以指定的时间段返回此OffsetTime的副本，以秒为单位。
    这样就增加了指定的秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds - 添加的秒数可能为负数
    
    结果
    
    一个 OffsetTime基于此时间与秒添加，不为null
  - plusNanos
```
public OffsetTime plusNanos(long nanos)
```
    返回这个OffsetTime一个副本，指定的时间段以纳秒为单位。
    这样就增加了指定的纳秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos - nanos添加，可能是负的
    
    结果
    
    一个 OffsetTime基于这个时间加上纳秒，不为null
  - minus
```
public OffsetTime minus(TemporalAmount amountToSubtract)
```
    返回此次的副本，减去指定的金额。
    这将返回一个OffsetTime ，基于此，减去指定的数量。量通常是Duration但也可以是任何其他类型的实现TemporalAmount接口。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现减法，但是它通常会回调到minus(long, TemporalUnit) 。请参阅数量实施的文档，以确定是否可以成功减去它们。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在界面 Temporal
    
    参数
    
    amountToSubtract - 减去量，不为空
    
    结果
    
    一个 OffsetTime基于这个时间与减法，而不是null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public OffsetTime minus(long amountToSubtract,
                        TemporalUnit unit)
```
    返回此次的副本，减去指定的金额。
    这返回一个OffsetTime ，基于这一个，减去的单位数量。如果不可能减去金额，因为该单位不受支持或出于某种其他原因，则会抛出异常。
    
    这种方法相当于plus(long, TemporalUnit) ，数量被否定。请参阅该方法，以了解如何添加，从而减去运算。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在界面 Temporal
    
    参数
    
    amountToSubtract - 从结果中减去的单位数量可能为负数
    
    unit - 减去量的单位，不为空
    
    结果
    
    一个 OffsetTime基于此时间减去指定的数量，不为null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - minusHours
```
public OffsetTime minusHours(long hours)
```
    以指定的时间段返回此OffsetTime的副本， OffsetTime数小时。
    这样从这个时间减去指定的小时数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours - 减去的时间可能是负数
    
    结果
    
    一个 OffsetTime基于此时间减去的小时数，不为空
  - minusMinutes
```
public OffsetTime minusMinutes(long minutes)
```
    以指定的时间段返回此OffsetTime的副本，以分钟为单位。
    这将从此时间减去指定的分钟数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes - 减去的 minutes可能为负数
    
    结果
    
    一个 OffsetTime基于此时间减去了分数，而不是null
  - minusSeconds
```
public OffsetTime minusSeconds(long seconds)
```
    以指定的时间段返回此OffsetTime的副本，以秒为单位。
    从此时间减去指定的秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds - 减去秒数，可能为负数
    
    结果
    
    一个 OffsetTime基于此时间减去秒，不为空
  - minusNanos
```
public OffsetTime minusNanos(long nanos)
```
    以指定的时间段返回此OffsetTime的副本，减去纳秒。
    从这个时间减去指定的纳秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos - nanos减去，可能是负数
    
    结果
    
    一个 OffsetTime基于此时间减去纳秒，不为零
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    此时使用指定的查询进行查询。
    这样可以使用指定的查询策略对象查询此时间。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档，以了解该方法的结果。
    
    该方法的结果是通过调用TemporalQuery.queryFrom(TemporalAccessor)方法获得的指定查询通过this作为参数。
    
    Specified by:
    
    query在界面 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，不为空
    
    结果
    
    查询结果可能返回null（由查询定义）
    
    异常
    
    DateTimeException - 如果无法查询（由查询定义）
    
    ArithmeticException - 如果发生数字溢出（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象与此对象具有相同的偏移量和时间。
    这返回与具有偏移和时间的输入相同的可观察类型的时间对象与此相同。
    
    调整相当于使用Temporal.with(TemporalField, long)两次，通过ChronoField.NANO_OF_DAY和ChronoField.OFFSET_SECONDS作为字段。
    
    在大多数情况下，通过使用Temporal.with(TemporalAdjuster)来更正呼叫模式：
```
  // these two lines are equivalent, but the second approach is recommended
   temporal = thisOffsetTime.adjustInto(temporal);
   temporal = temporal.with(thisOffsetTime); 
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto在界面 TemporalAdjuster
    
    参数
    
    temporal - 要调整的目标对象，不为null
    
    结果
    
    调整对象，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定的单位计算直到另一次的时间量。
    这可以计算两个OffsetTime对象之间的时间量，单个TemporalUnit 。起点和终点是this和指定的时间。如果结束在开始之前，结果将为负数。例如，可以使用startTime.until(endTime, HOURS)两次之间的时间startTime.until(endTime, HOURS) 。
    
    所述Temporal传递给此方法被转换为OffsetTime使用from(TemporalAccessor) 。如果偏移量在两次之间不同，则指定的结束时间被归一化为与此时间相同的偏移量。
    
    计算返回一个整数，表示两次之间的完整单位数。例如，11时30分至13时29分之间的小时只有一个小时，因为只有两分钟的时间。
    
    使用这种方法有两种等效的方法。第一个是调用这个方法。二是使用TemporalUnit.between(Temporal, Temporal) ：
```
  // these two lines are equivalent
   amount = start.until(end, MINUTES);
   amount = MINUTES.between(start, end); 
```
    应该根据这种做法进行选择，使代码更易读。
    ChronoUnit的这种方法的计算是实现的。单位NANOS ， MICROS ， MILLIS ， SECONDS ， MINUTES ， HOURS和HALF_DAYS都支持。其他ChronoUnit值将抛出异常。
    
    如果该单元不是ChronoUnit ，则此方法的结果是通过调用获得TemporalUnit.between(Temporal, Temporal)传递this作为第一个参数和转换后的输入时间作为第二个参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until在界面 Temporal
    
    参数
    
    endExclusive - 结束日期，排他，转换为 OffsetTime ，不为空
    
    unit - 衡量金额的单位，不为空
    
    结果
    
    这段时间与结束时间之间的时间量
    
    异常
    
    DateTimeException - 如果不能计算金额，或者结束时间不能转换为 OffsetTime
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - format
```
public String format(DateTimeFormatter formatter)
```
    此时使用指定的格式化程序格式化。
    这一次将被传递给格式化程序来生成一个字符串。
    
    参数
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    格式化的时间字符串，不为null
    
    异常
    
    DateTimeException - 打印时是否发生错误
  - atDate
```
public OffsetDateTime atDate(LocalDate date)
```
    结合这个时间与一个日期创建一个OffsetDateTime 。
    这将返回OffsetDateTime从这个时间和指定日期的形成。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    date - 要结合的日期，不为空
    
    结果
    
    从此时间和指定日期形成的偏移日期时间，不为空
  - compareTo
```
public int compareTo(OffsetTime other)
```
    比较这个OffsetTime到另一个时间。
    比较首先是基于UTC等效瞬间，然后在当地时间。它与“等于”一致，如Comparable所定义。
    
    例如，以下是比较器顺序：
    1. 10:30+01:00
    2. 11:00+01:00
    3. 12:00+02:00
    4. 11:30+01:00
    5. 12:00+01:00
    6. 12:30+01:00
    值2和＃3表示时间线上相同的时刻。当两个值表示相同的时刻时，比较本地时间以区分它们。需要这一步才能使订购与equals() 。
    要比较两个TemporalAccessor实例的基本本地时间，请使用ChronoField.NANO_OF_DAY作为比较器。
    Specified by:
    
    compareTo在界面 Comparable<OffsetTime>
    
    参数
    
    other - 其他时间比较，不为null
    
    结果
    
    比较器值为负，如果较小，则如果较大则为正
    
    异常
    
    NullPointerException - 如果 other为空
  - isAfter
```
public boolean isAfter(OffsetTime other)
```
    检查此OffsetTime是否在指定时间之后，将两次应用于通用日期。
    此方法不同于在比较compareTo(java.time.OffsetTime)在于其只比较的时间的时刻。这相当于使用相同的日期将时间转换为即时，并将时刻进行比较。
    
    参数
    
    other - 其他时间比较，不为null
    
    结果
    
    如果这是在指定时间之后的时间，则为true
  - isBefore
```
public boolean isBefore(OffsetTime other)
```
    检查此OffsetTime是否在指定的时间之前，将两次都应用到通用日期。
    此方法不同于在比较compareTo(java.time.OffsetTime)在于其只比较的时间的时刻。这相当于使用相同的日期将时间转换为即时，并将时刻进行比较。
    
    参数
    
    other - 其他时间比较，不为null
    
    结果
    
    如果这是在指定时间的时间之前，则为true
  - isEqual
```
public boolean isEqual(OffsetTime other)
```
    检查这个OffsetTime是否等于指定的时间，这两个时间都应用到公共日期。
    这种方法与compareTo(java.time.OffsetTime)和equals(java.lang.Object)中的比较有所不同，它只比较了时间的瞬间。这相当于使用相同的日期将时间转换为即时，并将时刻进行比较。
    
    参数
    
    other - 其他时间比较，不为空
    
    结果
    
    如果这等于指定时间的时间，则为true
  - equals
```
public boolean equals(Object obj)
```
    检查这次是否等于另一次。
    比较是基于本地时间和偏移量。要在时间线上比较同一时刻，请使用isEqual(OffsetTime) 。
    
    只比较类型为OffsetTime对象，其他类型返回false。要比较两个TemporalAccessor实例的基础本地时间，请使用ChronoField.NANO_OF_DAY作为比较器。
    
    重写：
    
    equals在类别 Object
    
    参数
    
    obj - 要检查的对象，null返回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 ，如10:15:30+01:00 。
    输出将是以下ISO-8601格式之一：
    - HH:mmXXXXX
    - HH:mm:ssXXXXX
    - HH:mm:ss.SSSXXXXX
    - HH:mm:ss.SSSSSSXXXXX
    - HH:mm:ss.SSSSSSSSSXXXXX
    所使用的格式将是将省略部分隐含为零的时间的全部值输出的最短。
    重写：
    
    toString在类别 Object
    
    结果
    
    这个时间的字符串表示，不为null

Class OffsetTime

Field Summary

方法摘要

Methods inherited from class java.lang.Object

字段详细信息

MIN

MAX

方法详细信息

now

now

now

of

of

ofInstant

from

parse

parse

isSupported

isSupported

range

get

getLong

getOffset

withOffsetSameLocal

withOffsetSameInstant

toLocalTime

getHour

getMinute

getSecond

getNano

with

with

withHour

withMinute

withSecond

withNano

truncatedTo

plus

plus

plusHours

plusMinutes

plusSeconds

plusNanos

minus

minus

minusHours

minusMinutes

minusSeconds

minusNanos

query

adjustInto

until

format

atDate

compareTo

isAfter

isBefore

isEqual

equals

hashCode

toString